review fix

Author: mertcanaltin

lib/logger.js

@@ -83,6 +83,14 @@ class LogConsumer {
     const { level = 'info' } = options;
     validateOneOf(level, 'options.level', LEVEL_NAMES);
     this.#levelValue = LEVELS[level];
+
+    // Setup level-specific enabled properties for typo safety
+    // Allows consumer.info.enabled instead of consumer.enabled('info')
+    const levelValue = this.#levelValue;
+    for (let i = 0; i < LEVEL_NAMES.length; i++) {
+      const lvl = LEVEL_NAMES[i];
+      this[lvl] = { __proto__: null, enabled: LEVELS[lvl] >= levelValue };
+    }
   }
 
   /**
@@ -249,8 +257,9 @@ class Logger {
     validateObject(bindings, 'options.bindings');
     validateObject(serializers, 'options.serializers');
 
-    // Validate serializers are functions
-    for (const key in serializers) {
+    // Validate serializers are functions (use ObjectKeys to avoid prototype chain)
+    const serializerKeys = ObjectKeys(serializers);
+    for (const key of serializerKeys) {
       validateFunction(serializers[key], `options.serializers.${key}`);
     }
 
@@ -263,8 +272,8 @@ class Logger {
     // Add default err serializer (can be overridden)
     this.#serializers.err = stdSerializers.err;
 
-    // Add custom serializers
-    for (const key in serializers) {
+    // Add custom serializers (use serializerKeys from validation above)
+    for (const key of serializerKeys) {
       this.#serializers[key] = serializers[key];
     }
 
@@ -416,25 +425,28 @@ class Logger {
   }
 
   /**
-   * Serialize a single value using serialize symbol or field serializer
+   * Serialize a single value using serialize symbol and/or field serializer
+   * Uses stacked behavior: first apply [serialize](), then field serializer
    * @param {*} value - Value to serialize
    * @param {string} key - Field key for field-specific serializer lookup
    * @returns {*} Serialized value
    * @private
    */
   #serializeValue(value, key) {
-    // Check for serialize symbol first
-    if (value !== null && typeof value === 'object' &&
-        typeof value[serialize] === 'function') {
-      return value[serialize]();
+    let result = value;
+
+    // Step 1: Apply [serialize](), if present
+    if (result !== null && typeof result === 'object' &&
+        typeof result[serialize] === 'function') {
+      result = result[serialize]();
     }
 
-    // Apply field-specific serializer if exists
+    // Step 2: Apply field-specific serializer, if present
     if (this.#serializers[key]) {
-      return this.#serializers[key](value);
+      result = this.#serializers[key](result);
     }
 
-    return value;
+    return result;
   }
 
   /**

test/parallel/test-logger-serializers.js

@@ -233,7 +233,7 @@ describe('Logger serializers', () => {
       assert.strictEqual(log.user.password, undefined);
     });
 
-    it('should prefer serialize symbol over field serializer', () => {
+    it('should apply both serialize symbol and field serializer (stacked)', () => {
       const stream = new TestStream();
       const consumer = new JSONConsumer({ stream, level: 'info' });
       consumer.attach();
@@ -252,8 +252,8 @@ describe('Logger serializers', () => {
       const logger = new Logger({
         level: 'info',
         serializers: {
-          // This should be ignored when object has serialize symbol
-          conn: (c) => ({ host: c.host, fromSerializer: true }),
+          // This runs AFTER serialize symbol, receives the serialized result
+          conn: (c) => ({ ...c, fromSerializer: true }),
         },
       });
 
@@ -263,8 +263,8 @@ describe('Logger serializers', () => {
 
       const log = stream.logs[0];
       assert.strictEqual(log.conn.host, 'localhost');
-      assert.strictEqual(log.conn.type, 'db');
-      assert.strictEqual(log.conn.fromSerializer, undefined);
+      assert.strictEqual(log.conn.type, 'db'); // From [serialize]()
+      assert.strictEqual(log.conn.fromSerializer, true); // From field serializer
       assert.strictEqual(log.conn.password, undefined);
     });