implemented serialize symbol

Author: mertcanaltin

benchmark/logger/basic-json.js

@@ -40,7 +40,8 @@ function main({ n, scenario }) {
 
     case 'string-long': {
       // Long string message (100 chars)
-      const longMsg = 'This is a much longer log message that contains more text to serialize and process during logging operations';
+      const longMsg = 'This is a much longer log message that contains ' +
+        'more text to serialize and process during logging operations';
       bench.start();
       for (let i = 0; i < n; i++) {
         logger.info(longMsg);

doc/api/logger.md

@@ -641,6 +641,78 @@ channels.info.subscribe((record) => {
 });
 ```
 
+## `logger.serialize`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {symbol}
+
+A symbol that objects can implement to define custom serialization behavior
+for logging. Similar to [`util.inspect.custom`][].
+
+When an object with a `[serialize]()` method is logged, the logger will call
+that method instead of serializing the object directly. This allows objects
+to control which properties are included in logs, filtering out sensitive
+data like passwords or tokens.
+
+```mjs
+import { Logger, JSONConsumer, serialize } from 'node:logger';
+
+class User {
+  constructor(id, name, password) {
+    this.id = id;
+    this.name = name;
+    this.password = password; // Sensitive!
+  }
+
+  // Define custom serialization
+  [serialize]() {
+    return {
+      id: this.id,
+      name: this.name,
+      // password is excluded
+    };
+  }
+}
+
+const consumer = new JSONConsumer();
+consumer.attach();
+
+const logger = new Logger();
+const user = new User(1, 'Alice', 'secret123');
+
+logger.info({ msg: 'User logged in', user });
+// Output: {"level":"info","time":...,"msg":"User logged in","user":{"id":1,"name":"Alice"}}
+// Note: password is not included in the output
+```
+
+```cjs
+const { Logger, JSONConsumer, serialize } = require('node:logger');
+
+class DatabaseConnection {
+  constructor(host, user, password) {
+    this.host = host;
+    this.user = user;
+    this.password = password;
+  }
+
+  [serialize]() {
+    return {
+      host: this.host,
+      user: this.user,
+      connected: this.isConnected,
+      // password is excluded
+    };
+  }
+}
+```
+
+The `serialize` symbol takes precedence over field-specific serializers.
+If an object has both a `[serialize]()` method and a matching serializer
+in the logger's `serializers` option, the `[serialize]()` method will be used.
+
 ## Examples
 
 ### Basic usage
@@ -764,3 +836,4 @@ consumer.attach();
 
 [RFC 5424]: https://www.rfc-editor.org/rfc/rfc5424.html
 [`logger.<level>.enabled`]: #loggerlevelenabled
+[`util.inspect.custom`]: util.md#utilinspectcustom

lib/logger.js

@@ -7,10 +7,19 @@ const {
   ObjectHasOwn,
   ObjectKeys,
   SafeSet,
+  SymbolFor,
 } = primordials;
 
 const { isNativeError } = require('internal/util/types');
 
+/**
+ * Symbol for custom serialization.
+ * Objects can implement this method to control how they are serialized in logs.
+ * Similar to util.inspect.custom.
+ * @type {symbol}
+ */
+const serialize = SymbolFor('nodejs.logger.serialize');
+
 const {
   codes: {
     ERR_INVALID_ARG_TYPE,
@@ -219,7 +228,6 @@ class Logger {
   #bindings;
   #bindingsStr; // Pre-serialized bindings JSON string
   #serializers;
-  #hasCustomSerializers;
 
   /**
    * Create a new Logger instance
@@ -255,16 +263,10 @@ class Logger {
     // Add default err serializer (can be overridden)
     this.#serializers.err = stdSerializers.err;
 
-    // Track if we have custom serializers beyond 'err'
-    let hasCustom = false;
     // Add custom serializers
     for (const key in serializers) {
       this.#serializers[key] = serializers[key];
-      if (key !== 'err') {
-        hasCustom = true;
-      }
     }
-    this.#hasCustomSerializers = hasCustom;
 
     // Pre-serialize bindings
     this.#bindingsStr = this.#serializeBindings(bindings);
@@ -285,11 +287,7 @@ class Logger {
 
     let result = '';
     for (const key in bindings) {
-      const value = bindings[key];
-      // Apply serializer if exists
-      const serialized = this.#serializers[key] ?
-        this.#serializers[key](value) :
-        value;
+      const serialized = this.#serializeValue(bindings[key], key);
       result += `,"${key}":${JSONStringify(serialized)}`;
     }
     return result;
@@ -416,6 +414,28 @@ class Logger {
     return childLogger;
   }
 
+  /**
+   * Serialize a single value using serialize symbol or 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]();
+    }
+
+    // Apply field-specific serializer if exists
+    if (this.#serializers[key]) {
+      return this.#serializers[key](value);
+    }
+
+    return value;
+  }
+
   /**
    * Apply serializers to an object's properties
    * @param {object} obj - Object to serialize
@@ -427,20 +447,10 @@ class Logger {
       return obj;
     }
 
-    // Fast path: no custom serializers, return as-is
-    if (!this.#hasCustomSerializers) {
-      return obj;
-    }
-
     const serialized = { __proto__: null };
-    const serializers = this.#serializers;
 
     for (const key in obj) {
-      const value = obj[key];
-      // Apply serializer if exists for this key
-      serialized[key] = serializers[key] ?
-        serializers[key](value) :
-        value;
+      serialized[key] = this.#serializeValue(obj[key], key);
     }
 
     return serialized;
@@ -580,4 +590,5 @@ module.exports = {
   LEVELS,
   channels,
   stdSerializers,
+  serialize,
 };

test/parallel/test-logger-serializers.js

@@ -4,7 +4,7 @@
 require('../common');
 const assert = require('node:assert');
 const { describe, it } = require('node:test');
-const { Logger, JSONConsumer, stdSerializers } = require('node:logger');
+const { Logger, JSONConsumer, stdSerializers, serialize } = require('node:logger');
 const { Writable } = require('node:stream');
 
 // Test helper to capture log output
@@ -201,4 +201,115 @@ describe('Logger serializers', () => {
       assert.strictEqual(log.data.secret, undefined);
     });
   });
+
+  describe('serialize symbol', () => {
+    it('should use serialize symbol for custom object serialization', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+
+      class User {
+        constructor(id, name, password) {
+          this.id = id;
+          this.name = name;
+          this.password = password;
+        }
+
+        [serialize]() {
+          return { id: this.id, name: this.name };
+        }
+      }
+
+      const logger = new Logger({ level: 'info' });
+      const user = new User(123, 'Alice', 'secret123');
+
+      logger.info({ msg: 'User logged in', user });
+      consumer.flushSync();
+
+      assert.strictEqual(stream.logs.length, 1);
+      const log = stream.logs[0];
+      assert.strictEqual(log.user.id, 123);
+      assert.strictEqual(log.user.name, 'Alice');
+      assert.strictEqual(log.user.password, undefined);
+    });
+
+    it('should prefer serialize symbol over field serializer', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+
+      class Connection {
+        constructor(host, password) {
+          this.host = host;
+          this.password = password;
+        }
+
+        [serialize]() {
+          return { host: this.host, type: 'db' };
+        }
+      }
+
+      const logger = new Logger({
+        level: 'info',
+        serializers: {
+          // This should be ignored when object has serialize symbol
+          conn: (c) => ({ host: c.host, fromSerializer: true }),
+        },
+      });
+
+      const conn = new Connection('localhost', 'secret');
+      logger.info({ msg: 'Connected', conn });
+      consumer.flushSync();
+
+      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.password, undefined);
+    });
+
+    it('should work with child logger bindings', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+
+      class RequestContext {
+        constructor(id, internalToken) {
+          this.id = id;
+          this.internalToken = internalToken;
+        }
+
+        [serialize]() {
+          return { requestId: this.id };
+        }
+      }
+
+      const logger = new Logger({ level: 'info' });
+      const ctx = new RequestContext('req-456', 'internal-secret');
+      const childLogger = logger.child({ ctx });
+
+      childLogger.info({ msg: 'Processing' });
+      consumer.flushSync();
+
+      const log = stream.logs[0];
+      assert.strictEqual(log.ctx.requestId, 'req-456');
+      assert.strictEqual(log.ctx.internalToken, undefined);
+    });
+
+    it('should handle objects without serialize symbol normally', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+
+      const logger = new Logger({ level: 'info' });
+      const data = { foo: 'bar', count: 42 };
+
+      logger.info({ msg: 'Plain object', data });
+      consumer.flushSync();
+
+      const log = stream.logs[0];
+      assert.strictEqual(log.data.foo, 'bar');
+      assert.strictEqual(log.data.count, 42);
+    });
+  });
 });