use single diagnostics channel with consumer-side filtering

Signed-off-by: Mert Can Altin <mertgold60@gmail.com>

Author: mertcanaltin

lib/logger.js

@@ -5,6 +5,7 @@ const {
   ObjectAssign,
   ObjectDefineProperty,
   ObjectKeys,
+  SafeWeakMap,
   SymbolFor,
 } = primordials;
 
@@ -38,17 +39,6 @@ const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
 emitExperimentalWarning('Logger');
 const stdSerializers = require('internal/logger/serializers');
 
-// Create channels for each log level
-const channels = {
-  __proto__: null,
-  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
 * @link https://www.rfc-editor.org/rfc/rfc5424.html
@@ -63,6 +53,8 @@ const LEVELS = {
   fatal: 60,
 };
 
+const channel = diagnosticsChannel.channel('log');
+
 const LEVEL_NAMES = ObjectKeys(LEVELS);
 
 function isReservedKey(key) {
@@ -79,15 +71,15 @@ function noop() {}
 class LogConsumer {
   /** @type {number} */
   #levelValue;
-  #handlers;
+  #handler;
   #attached;
 
   constructor(options = kEmptyObject) {
     validateObject(options, 'options');
     const { level = 'info' } = options;
     validateOneOf(level, 'options.level', LEVEL_NAMES);
     this.#levelValue = LEVELS[level];
-    this.#handlers = { __proto__: null };
+    this.#handler = undefined;
     this.#attached = false;
 
     // Setup level-specific enabled properties for typo safety
@@ -100,20 +92,20 @@ class LogConsumer {
   }
 
   /**
-   * Attach this consumer to log channels
+   * Attach this consumer to log channel
    */
   attach() {
     if (this.#attached) {
       return;
     }
     this.#attached = true;
-    for (const level of LEVEL_NAMES) {
-      if (this[level].enabled) {
-        const handler = this.handle.bind(this);
-        this.#handlers[level] = handler;
-        channels[level].subscribe(handler);
+    this.#handler = (record) => {
+      if (record.levelValue < this.#levelValue) {
+        return;
       }
-    }
+      this.handle(record);
+    };
+    channel.subscribe(this.#handler);
   }
 
   /**
@@ -124,12 +116,8 @@ class LogConsumer {
       return;
     }
     this.#attached = false;
-    for (const level of LEVEL_NAMES) {
-      if (this.#handlers[level]) {
-        channels[level].unsubscribe(this.#handlers[level]);
-        this.#handlers[level] = undefined;
-      }
-    }
+    channel.unsubscribe(this.#handler);
+    this.#handler = undefined;
   }
 
   /**
@@ -147,6 +135,7 @@ class LogConsumer {
 class JSONConsumer extends LogConsumer {
   #stream;
   #fields;
+  #bindingsCache;
 
   constructor(options = kEmptyObject) {
     super(options);
@@ -160,6 +149,7 @@ class JSONConsumer extends LogConsumer {
     this.#stream = stream ? this.#createStream(stream) :
       new Utf8Stream({ fd: 1 });
     this.#fields = fields;
+    this.#bindingsCache = new SafeWeakMap();
   }
 
   #createStream(stream) {
@@ -199,6 +189,10 @@ class JSONConsumer extends LogConsumer {
     // record.level is trusted internal value, record.msg is user input and must be escaped
     let json = `{"level":"${record.level}","time":${record.time},"msg":${JSONStringify(record.msg)}`;
 
+    if (record.name !== undefined) {
+      json += `,${JSONStringify('name')}:${JSONStringify(record.name)}`;
+    }
+
     const consumerFields = this.#fields;
     const consumerKeys = ObjectKeys(consumerFields);
     for (let i = 0; i < consumerKeys.length; i++) {
@@ -209,8 +203,8 @@ class JSONConsumer extends LogConsumer {
       json += `,${JSONStringify(key)}:${JSONStringify(value)}`;
     }
 
-    // Add pre-serialized bindings
-    json += record.bindingsStr;
+    // Add bindings, cached per bindings object to avoid rebuilding on every log
+    json += this.#serializeBindings(record.bindings);
 
     // Add log fields
     const fields = record.fields;
@@ -227,6 +221,30 @@ class JSONConsumer extends LogConsumer {
     this.#stream.write(json);
   }
 
+  #serializeBindings(bindings) {
+    if (!bindings || typeof bindings !== 'object') {
+      return '';
+    }
+
+    const cached = this.#bindingsCache.get(bindings);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    let result = '';
+    const keys = ObjectKeys(bindings);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (isReservedKey(key)) continue;
+      const value = bindings[key];
+      if (value === undefined) continue;
+      result += `,${JSONStringify(key)}:${JSONStringify(value)}`;
+    }
+
+    this.#bindingsCache.set(bindings, result);
+    return result;
+  }
+
   /**
    * Flush pending writes
    * @param {Function} callback
@@ -259,26 +277,32 @@ class Logger {
   #level;
   #levelValue;
   #bindings;
-  #bindingsStr; // Pre-serialized bindings JSON string
+  #name;
   #serializers;
 
   /**
    * Create a new Logger instance
    * @param {object} [options]
    * @param {string} [options.level] - Minimum log level (default: 'info')
+   * @param {string} [options.name] - Optional logger name/namespace
    * @param {object} [options.bindings] - Context fields (default: {})
    * @param {object} [options.serializers] - Custom serializers (default: {})
    */
   constructor(options = kEmptyObject) {
     validateObject(options, 'options');
     const {
       level = 'info',
+      name,
       bindings = kEmptyObject,
       serializers = kEmptyObject,
     } = options;
 
     validateOneOf(level, 'options.level', LEVEL_NAMES);
 
+    if (name !== undefined) {
+      validateString(name, 'options.name');
+    }
+
     validateObject(bindings, 'options.bindings');
     validateObject(serializers, 'options.serializers');
 
@@ -290,6 +314,7 @@ class Logger {
 
     this.#level = level;
     this.#levelValue = LEVELS[level];
+    this.#name = name;
     this.#bindings = bindings;
 
     // Create serializers object with default err serializer
@@ -302,35 +327,10 @@ class Logger {
       this.#serializers[key] = serializers[key];
     }
 
-    // Pre-serialize bindings
-    this.#bindingsStr = this.#serializeBindings(bindings);
 
     this.#setLogMethods();
   }
 
-  /**
-   * Pre-serialize bindings
-   * @param {object} bindings - Context fields to serialize
-   * @returns {string} Pre-serialized bindings as JSON string
-   * @private
-   */
-  #serializeBindings(bindings) {
-    if (!bindings || typeof bindings !== 'object') {
-      return '';
-    }
-
-    let result = '';
-    const keys = ObjectKeys(bindings);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (isReservedKey(key)) continue;
-      const serialized = this.#serializeValue(bindings[key], key);
-      if (serialized === undefined) continue;
-      result += `,${JSONStringify(key)}:${JSONStringify(serialized)}`;
-    }
-    return result;
-  }
-
   /**
    * Setup log methods with enabled getters.
    *
@@ -502,7 +502,6 @@ class Logger {
       return;
     }
 
-    const channel = channels[level];
     if (!channel.hasSubscribers) {
       return;
     }
@@ -557,9 +556,11 @@ class Logger {
     const record = {
       __proto__: null,
       level,
+      levelValue,
+      name: this.#name,
       msg,
       time: DateNow(),
-      bindingsStr: this.#bindingsStr, // Pre-serialized bindings string
+      bindings: this.#bindings,
       fields: logFields,
     };
 

test/parallel/test-log-basic.js

@@ -291,6 +291,22 @@ describe('JSONConsumer', () => {
       assert.strictEqual(log.userId, 123);
       assert.strictEqual(typeof log.time, 'number');
     });
+
+    it('should include logger name when provided', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+      const logger = new Logger({ level: 'info', name: 'api' });
+
+      logger.info({ msg: 'named logger', userId: 123 });
+      consumer.flushSync();
+
+      assert.strictEqual(stream.logs.length, 1);
+      const log = stream.logs[0];
+      assert.strictEqual(log.name, 'api');
+      assert.strictEqual(log.msg, 'named logger');
+      assert.strictEqual(log.userId, 123);
+    });
   });
 
   describe('additional fields', () => {