lib: refactor logger to use diagnostics_channel

Author: mertcanaltin

lib/logger.js

@@ -23,6 +23,17 @@ const {
 } = require('internal/validators');
 
 const Utf8Stream = require('internal/streams/fast-utf8-stream');
+const diagnosticsChannel = require('diagnostics_channel');
+
+// Create channels for each log level
+const channels = {
+  trace: diagnosticsChannel.channel('log:trace'),
+  debug: diagnosticsChannel.channel('log:debug'),
+  info: diagnosticsChannel.channel('log:info'),
+  warn: diagnosticsChannel.channel('log:warn'),
+  error: diagnosticsChannel.channel('log:error'),
+  fatal: diagnosticsChannel.channel('log:fatal'),
+};
 
 // RFC5424 numerical ordering + log4j interface
 const LEVELS = {
@@ -39,7 +50,11 @@ const LEVEL_NAMES = ObjectKeys(LEVELS);
 // Noop function for disabled log levels
 function noop() {}
 
-class Handler {
+/**
+ * Base consumer class for handling log records
+ * Consumers subscribe to diagnostics_channel events
+ */
+class LogConsumer {
   constructor(options = {}) {
     validateObject(options, 'options');
     const { level = 'info' } = options;
@@ -51,11 +66,11 @@ class Handler {
     }
 
     this._level = level;
-    this._levelValue = LEVELS[level]; // Cache numeric value
+    this._levelValue = LEVELS[level];
   }
 
   /**
-   * Check if a level would be logged
+   * Check if a level would be consumed
    * @param {string} level
    * @returns {boolean}
    */
@@ -64,18 +79,39 @@ class Handler {
   }
 
   /**
-   * Handle a log record
+   * Attach this consumer to log channels
+   */
+  attach() {
+    for (const level of LEVEL_NAMES) {
+      if (this.enabled(level)) {
+        channels[level].subscribe(this._handleLog.bind(this, level));
+      }
+    }
+  }
+
+  /**
+   * Internal handler called by diagnostics_channel
+   * @param {string} level
+   * @param {object} record
+   * @private
+   */
+  _handleLog(level, record) {
+    this.handle(record);
+  }
+
+  /**
+   * Handle a log record (must be implemented by subclass)
    * @param {object} record
    */
   handle(record) {
-    throw new ERR_METHOD_NOT_IMPLEMENTED('Handler.handle()');
+    throw new ERR_METHOD_NOT_IMPLEMENTED('LogConsumer.handle()');
   }
 }
 
 /**
- * JSON handler - outputs structured JSON logs
+ * JSON consumer - outputs structured JSON logs
  */
-class JSONHandler extends Handler {
+class JSONConsumer extends LogConsumer {
   constructor(options = {}) {
     super(options);
     const {
@@ -85,24 +121,20 @@ class JSONHandler extends Handler {
 
     validateObject(fields, 'options.fields');
 
-    // Default to stdout
     this._stream = stream ? this._createStream(stream) :
       new Utf8Stream({ fd: 1 });
     this._fields = fields;
   }
 
   _createStream(stream) {
-    // If it's already a Utf8Stream, use it directly
     if (stream instanceof Utf8Stream) {
       return stream;
     }
 
-    // If it's a file descriptor number
     if (typeof stream === 'number') {
       return new Utf8Stream({ fd: stream });
     }
 
-    // If it's a path string
     if (typeof stream === 'string') {
       return new Utf8Stream({ dest: stream });
     }
@@ -113,17 +145,13 @@ class JSONHandler extends Handler {
   }
 
   handle(record) {
-    // Note: Level check already done in Logger._log()
-    // No need to check again here
-
-    // Build the JSON log record
     const logObj = {
       level: record.level,
       time: record.time,
       msg: record.msg,
-      ...this._fields,      // Additional fields (hostname, pid, etc)
-      ...record.bindings,   // Parent context
-      ...record.fields,     // Log-specific fields
+      ...this._fields,
+      ...record.bindings,
+      ...record.fields,
     };
 
     const json = JSONStringify(logObj) + '\n';
@@ -146,7 +174,7 @@ class JSONHandler extends Handler {
   }
 
   /**
-   * Close the handler
+   * Close the consumer
    */
   end() {
     this._stream.end();
@@ -160,34 +188,22 @@ class Logger {
   constructor(options = {}) {
     validateObject(options, 'options');
     const {
-      handler = new JSONHandler(),
-      level,
+      level = 'info',
       bindings = {},
     } = options;
 
-    if (!(handler instanceof Handler)) {
-      throw new ERR_INVALID_ARG_TYPE('options.handler', 'Handler', handler);
+    validateString(level, 'options.level');
+    if (!LEVELS[level]) {
+      throw new ERR_INVALID_ARG_VALUE('options.level', level,
+                                      `must be one of: ${LEVEL_NAMES.join(', ')}`);
     }
 
     validateObject(bindings, 'options.bindings');
 
-    this._handler = handler;
+    this._level = level;
+    this._levelValue = LEVELS[level];
     this._bindings = bindings;
 
-    // If level is specified, it overrides handler's level
-    if (level !== undefined) {
-      validateString(level, 'options.level');
-      if (!LEVELS[level]) {
-        throw new ERR_INVALID_ARG_VALUE('options.level', level,
-                                        `must be one of: ${LEVEL_NAMES.join(', ')}`);
-      }
-      this._level = level;
-      this._levelValue = LEVELS[level]; // Cache numeric value
-    } else {
-      this._level = handler._level;
-      this._levelValue = handler._levelValue; // Use handler's cached value
-    }
-
     // Optimize: replace disabled log methods with noop
     this._setLogMethods();
   }
@@ -199,8 +215,6 @@ class Logger {
   _setLogMethods() {
     const levelValue = this._levelValue;
 
-    // Override instance methods for disabled levels
-    // This avoids the level check on every call
     if (levelValue > 10) this.trace = noop;
     if (levelValue > 20) this.debug = noop;
     if (levelValue > 30) this.info = noop;
@@ -228,16 +242,13 @@ class Logger {
     validateObject(bindings, 'bindings');
     validateObject(options, 'options');
 
-    // Shallow merge parent and child bindings
     const mergedBindings = ObjectAssign(
       { __proto__: null },
       this._bindings,
       bindings,
     );
 
-    // Create new logger inheriting handler
     return new Logger({
-      handler: this._handler,
       level: options.level || this._level,
       bindings: mergedBindings,
     });
@@ -264,28 +275,24 @@ class Logger {
    * @param {object} [fields] - Optional fields to merge
    */
   _log(level, levelValue, msgOrObj, fields) {
+    if (levelValue < this._levelValue) {
+      return;
+    }
+
     let msg;
     let logFields;
 
-    // Support two signatures:
-    // 1. logger.info('message', { fields })
-    // 2. logger.info({ msg: 'message', other: 'fields' })
-    // 3. logger.info(new Error('boom'))
-
     if (this._isError(msgOrObj)) {
-      // Handle Error as first argument
       msg = msgOrObj.message;
       logFields = {
         err: this._serializeError(msgOrObj),
         ...fields,
       };
     } else if (typeof msgOrObj === 'string') {
-      // Support String message
       msg = msgOrObj;
       logFields = fields || {};
       validateObject(logFields, 'fields');
     } else {
-      // Support object with msg property
       validateObject(msgOrObj, 'obj');
       if (typeof msgOrObj.msg !== 'string') {
         throw new ERR_INVALID_ARG_TYPE('obj.msg', 'string', msgOrObj.msg);
@@ -294,13 +301,11 @@ class Logger {
       msg = extractedMsg;
       logFields = restFields;
 
-      // Serialize Error objects in fields
       if (logFields.err && this._isError(logFields.err)) {
         logFields.err = this._serializeError(logFields.err);
       }
     }
 
-    // Build log record
     const record = {
       level,
       msg,
@@ -309,7 +314,10 @@ class Logger {
       fields: logFields,
     };
 
-    this._handler.handle(record);
+    const channel = channels[level];
+    if (channel.hasSubscribers) {
+      channel.publish(record);
+    }
   }
 
   /**
@@ -325,95 +333,51 @@ class Logger {
       stack: err.stack,
     };
 
-    // Add code if it exists
     serialized.code ||= err.code;
 
-    // Add any enumerable custom properties
     for (const key in err) {
       serialized[key] ||= err[key];
     }
 
     return serialized;
   }
 
-  /**
-   * Log at trace level
-   * @param {string|object} msgOrObj - Message string or object with msg property
-   * @param {object} [fields] - Optional fields to merge
-   */
   trace(msgOrObj, fields) {
     this._log('trace', 10, msgOrObj, fields);
   }
 
-  /**
-   * Log at debug level
-   * @param {string|object} msgOrObj - Message string or object with msg property
-   * @param {object} [fields] - Optional fields to merge
-   */
   debug(msgOrObj, fields) {
     this._log('debug', 20, msgOrObj, fields);
   }
 
-  /**
-   * Log at info level
-   * @param {string|object} msgOrObj - Message string or object with msg property
-   * @param {object} [fields] - Optional fields to merge
-   */
   info(msgOrObj, fields) {
     this._log('info', 30, msgOrObj, fields);
   }
 
-  /**
-   * Log at warn level
-   * @param {string|object} msgOrObj - Message string or object with msg property
-   * @param {object} [fields] - Optional fields to merge
-   */
   warn(msgOrObj, fields) {
     this._log('warn', 40, msgOrObj, fields);
   }
 
-  /**
-   * Log at error level
-   * @param {string|object} msgOrObj - Message string or object with msg property
-   * @param {object} [fields] - Optional fields to merge
-   */
   error(msgOrObj, fields) {
     this._log('error', 50, msgOrObj, fields);
   }
 
-  /**
-   * Log at fatal level (does NOT exit the process)
-   * @param {string|object} msgOrObj - Message string or object with msg property
-   * @param {object} [fields] - Optional fields to merge
-   */
   fatal(msgOrObj, fields) {
     this._log('fatal', 60, msgOrObj, fields);
   }
-
-  /**
-   * Flush pending writes
-   * @param {Function} callback
-   */
-  flush(callback) {
-    this._handler.flush(callback);
-  }
 }
 
-/**
- * Create a new logger instance
- * @param {object} [options]
- * @param {Handler} [options.handler] - Output handler (default: JSONHandler)
- * @param {string} [options.level] - Minimum log level (default: 'info')
- * @returns {Logger}
- */
 function createLogger(options) {
   return new Logger(options);
 }
 
 module.exports = {
   createLogger,
   Logger,
-  Handler,
-  JSONHandler,
+  LogConsumer,
+  JSONConsumer,
+  Handler: LogConsumer,
+  JSONHandler: JSONConsumer,
   LEVELS,
+  channels,
 };