add serializers support to logger API

Author: mertcanaltin

lib/internal/logger/serializers.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * Serializes an Error object
+ * @param {Error} error
+ * @returns {object}
+ */
+function serializeErr(error) {
+  if (!error || typeof error !== 'object') {
+    return error;
+  }
+
+  const obj = {
+    type: error.constructor.name,
+    message: error.message,
+    stack: error.stack,
+  };
+
+  // Include additional error properties
+  for (const key in error) {
+    if (obj[key] === undefined) {
+      obj[key] = error[key];
+    }
+  }
+
+  // Handle error code if present
+  if (error.code !== undefined) {
+    obj.code = error.code;
+  }
+
+  // Handle error cause recursively
+  if (error.cause !== undefined) {
+    obj.cause = typeof error.cause === 'object' && error.cause !== null ?
+      serializeErr(error.cause) :
+      error.cause;
+  }
+
+  return obj;
+}
+
+/**
+ * Serializes HTTP request object
+ * @param {object} req - HTTP request
+ * @returns {object}
+ */
+function req(req) {
+  return {
+    method: req.method,
+    url: req.url,
+    headers: req.headers,
+    remoteAddress: req.socket?.remoteAddress,
+    remotePort: req.socket?.remotePort,
+  };
+}
+
+/**
+ * Serializes HTTP response object
+ * @param {object} res - HTTP response
+ * @returns {object}
+ */
+function res(res) {
+  return {
+    statusCode: res.statusCode,
+    headers: res.getHeaders ? res.getHeaders() : res.headers,
+  };
+}
+
+module.exports = {
+  err: serializeErr,
+  req,
+  res,
+};

lib/logger.js

@@ -2,7 +2,7 @@
 
 const {
   DateNow,
-  Error,
+  ErrorIsError,
   JSONStringify,
   ObjectAssign,
   ObjectKeys,
@@ -21,11 +21,13 @@ const {
   validateObject,
   validateString,
   validateOneOf,
+  validateFunction,
 } = require('internal/validators');
 
 const Utf8Stream = require('internal/streams/fast-utf8-stream');
 const diagnosticsChannel = require('diagnostics_channel');
 const { kEmptyObject } = require('internal/util');
+const stdSerializers = require('internal/logger/serializers');
 
 // Create channels for each log level
 const channels = {
@@ -69,7 +71,6 @@ class LogConsumer {
 
     validateOneOf(level, 'options.level', LEVEL_NAMES);
 
-    this.#level = level;
     this.#levelValue = LEVELS[level];
   }
 
@@ -220,10 +221,15 @@ class Logger {
   #level;
   #levelValue;
   #bindings;
+  #serializers;
 
   constructor(options = kEmptyObject) {
     validateObject(options, 'options');
-    const { level = 'info', bindings = kEmptyObject } = options;
+    const {
+      level = 'info',
+      bindings = kEmptyObject,
+      serializers = kEmptyObject,
+    } = options;
 
     validateString(level, 'options.level');
     if (!LEVELS[level]) {
@@ -235,11 +241,26 @@ class Logger {
     }
 
     validateObject(bindings, 'options.bindings');
+    validateObject(serializers, 'options.serializers');
+
+    // Validate serializers are functions
+    for (const key in serializers) {
+      validateFunction(serializers[key], `options.serializers.${key}`);
+    }
 
     this.#level = level;
     this.#levelValue = LEVELS[level];
     this.#bindings = bindings;
 
+    // Create serializers object with default err serializer
+    this.#serializers = { __proto__: null };
+    // Add default err serializer (can be overridden)
+    this.#serializers.err = stdSerializers.err;
+    // Add custom serializers
+    for (const key in serializers) {
+      this.#serializers[key] = serializers[key];
+    }
+
     this.#setLogMethods();
   }
 
@@ -283,9 +304,30 @@ class Logger {
       bindings,
     );
 
+    // Handle serializers inheritance
+    let childSerializers;
+    if (options.serializers) {
+      validateObject(options.serializers, 'options.serializers');
+
+      // Create new serializers object
+      childSerializers = { __proto__: null };
+
+      // Copy parent serializers
+      for (const key in this.#serializers) {
+        childSerializers[key] = this.#serializers[key];
+      }
+
+      // Override with child serializers
+      for (const key in options.serializers) {
+        validateFunction(options.serializers[key], `options.serializers.${key}`);
+        childSerializers[key] = options.serializers[key];
+      }
+    }
+
     const childLogger = new Logger({
       level: options.level || this.#level,
       bindings: mergedBindings,
+      serializers: childSerializers || this.#serializers,
     });
 
     return childLogger;
@@ -298,7 +340,32 @@ class Logger {
    * @private
    */
   #isError(value) {
-    return Error.isError(value);
+    return ErrorIsError(value);
+  }
+
+  /**
+   * Apply serializers to an object's properties
+   * @param {object} obj - Object to serialize
+   * @returns {object} Serialized object
+   * @private
+   */
+  #applySerializers(obj) {
+    if (!obj || typeof obj !== 'object') {
+      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;
+    }
+
+    return serialized;
   }
 
   /**
@@ -332,24 +399,44 @@ class Logger {
 
     if (this.#isError(msgOrObj)) {
       msg = msgOrObj.message;
+      // Use err serializer for Error objects
+      const serializedErr = this.#serializers.err ?
+        this.#serializers.err(msgOrObj) :
+        this.#serializeError(msgOrObj);
+
       logFields = {
-        err: this.#serializeError(msgOrObj),
-        ...fields,
+        err: serializedErr,
       };
+
+      // Apply serializers to additional fields
+      if (fields) {
+        const serializedFields = this.#applySerializers(fields);
+        for (const key in serializedFields) {
+          logFields[key] = serializedFields[key];
+        }
+      }
     } else if (typeof msgOrObj === 'string') {
       msg = msgOrObj;
-      logFields = fields ?? kEmptyObject;
+      // Apply serializers to fields
+      logFields = fields ? this.#applySerializers(fields) : kEmptyObject;
     } else {
       const { msg: extractedMsg, ...restFields } = msgOrObj;
       msg = extractedMsg;
-      logFields = restFields;
 
-      if (logFields.err && this.#isError(logFields.err)) {
-        logFields.err = this.#serializeError(logFields.err);
+      // Apply serializers to object fields
+      logFields = this.#applySerializers(restFields);
+
+      // Special handling for err/error fields
+      if (logFields.err && this.#isError(restFields.err)) {
+        logFields.err = this.#serializers.err ?
+          this.#serializers.err(restFields.err) :
+          this.#serializeError(restFields.err);
       }
 
-      if (logFields.error && this.#isError(logFields.error)) {
-        logFields.error = this.#serializeError(logFields.error);
+      if (logFields.error && this.#isError(restFields.error)) {
+        logFields.error = this.#serializers.err ?
+          this.#serializers.err(restFields.error) :
+          this.#serializeError(restFields.error);
       }
     }
 
@@ -446,6 +533,7 @@ module.exports = {
   LEVELS,
   channels,
   createLogger,
+  stdSerializers,
   Handler: LogConsumer,
   JSONHandler: JSONConsumer,
 };