add enabled property to logger methods for performance checks

Author: mertcanaltin

doc/api/logger.md

@@ -260,6 +260,30 @@ requestLogger.info('Processing request');
 // Log includes: service: 'my-app', requestId: 'abc123'
 ```
 
+### `logger.<level>.enabled`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean} `true` if the level is enabled, `false` otherwise.
+
+Each log method (`trace`, `debug`, `info`, `warn`, `error`, `fatal`) has an
+`enabled` property that indicates whether that level is enabled for this logger.
+
+This is the recommended way to check if a level is enabled before performing
+expensive computations:
+
+```js
+if (logger.debug.enabled) {
+  // Perform expensive debug computation only if debug is enabled
+  logger.debug('Debug info', { expensiveData: computeDebugData() });
+}
+
+// Typos will throw a TypeError (safer than silent failure)
+// logger.debg.enabled → TypeError: Cannot read properties of undefined
+```
+
 ### `logger.enabled(level)`
 
 <!-- YAML
@@ -269,12 +293,19 @@ added: REPLACEME
 * `level` {string} The log level to check.
 * Returns: {boolean} `true` if the level is enabled, `false` otherwise.
 
-Checks if a specific log level is enabled for this logger.
+Checks if a specific log level is enabled for this logger. For most use cases,
+prefer using [`logger.<level>.enabled`][] instead, as it catches typos at
+runtime.
 
 ```js
+// Prefer this:
+if (logger.debug.enabled) {
+  logger.debug('message');
+}
+
+// Over this (typos won't throw):
 if (logger.enabled('debug')) {
-  // Perform expensive debug computation
-  logger.debug('Debug info', { expensiveData: computeDebugData() });
+  logger.debug('message');
 }
 ```
 
@@ -747,5 +778,4 @@ class ConsoleColorConsumer extends LogConsumer {
 const consumer = new ConsoleColorConsumer({ level: 'debug' });
 consumer.attach();
 ```
-
-[RFC 5424]: https://www.rfc-editor.org/rfc/rfc5424.html
+[`logger.<level>.enabled`]: #loggerlevelenabled

lib/logger.js

@@ -3,6 +3,7 @@ const {
   DateNow,
   JSONStringify,
   ObjectAssign,
+  ObjectDefineProperty,
   ObjectHasOwn,
   ObjectKeys,
   SafeSet,
@@ -303,18 +304,53 @@ class Logger {
   }
 
   /**
-   * Replace disabled log methods with noop for performance
+   * Setup log methods with enabled getters
    * @private
    */
   #setLogMethods() {
     const levelValue = this.#levelValue;
 
-    if (levelValue > LEVELS.trace) this.trace = noop;
-    if (levelValue > LEVELS.debug) this.debug = noop;
-    if (levelValue > LEVELS.info) this.info = noop;
-    if (levelValue > LEVELS.warn) this.warn = noop;
-    if (levelValue > LEVELS.error) this.error = noop;
-    if (levelValue > LEVELS.fatal) this.fatal = noop;
+    // Setup each log level method with .enabled getter
+    this.trace = this.#createLogMethod('trace', LEVELS.trace, levelValue);
+    this.debug = this.#createLogMethod('debug', LEVELS.debug, levelValue);
+    this.info = this.#createLogMethod('info', LEVELS.info, levelValue);
+    this.warn = this.#createLogMethod('warn', LEVELS.warn, levelValue);
+    this.error = this.#createLogMethod('error', LEVELS.error, levelValue);
+    this.fatal = this.#createLogMethod('fatal', LEVELS.fatal, levelValue);
+  }
+
+  /**
+   * Create a log method with .enabled getter
+   * @param {string} level - Log level name
+   * @param {number} methodLevelValue - Numeric value of this level
+   * @param {number} loggerLevelValue - Logger's minimum level value
+   * @returns {Function} Log method with .enabled property
+   * @private
+   */
+  #createLogMethod(level, methodLevelValue, loggerLevelValue) {
+    const enabled = methodLevelValue >= loggerLevelValue;
+
+    let fn;
+    if (enabled) {
+      // Create bound log function
+      fn = (msgOrObj, fields) => {
+        this.#log(level, methodLevelValue, msgOrObj, fields);
+      };
+    } else {
+      // Use noop for disabled levels
+      fn = noop;
+    }
+
+    // Add .enabled getter
+    ObjectDefineProperty(fn, 'enabled', {
+      __proto__: null,
+      value: enabled,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    });
+
+    return fn;
   }
 
   /**