lib: add logger module with diagnostics_channel

Author: mertcanaltin

lib/logger.js

@@ -2,10 +2,11 @@
 
 const {
   DateNow,
-  ErrorIsError,
+  Error,
   JSONStringify,
   ObjectAssign,
   ObjectKeys,
+  ObjectPrototypeToString,
   SafeSet,
 } = primordials;
 
@@ -129,21 +130,32 @@ class JSONConsumer extends LogConsumer {
   }
 
   _createStream(stream) {
+    // Fast path: already a Utf8Stream
     if (stream instanceof Utf8Stream) {
       return stream;
     }
 
+    // Number: file descriptor
     if (typeof stream === 'number') {
       return new Utf8Stream({ fd: stream });
     }
 
+    // String: file path
     if (typeof stream === 'string') {
       return new Utf8Stream({ dest: stream });
     }
 
-    throw new ERR_INVALID_ARG_TYPE('options.stream',
-                                   ['number', 'string', 'Utf8Stream'],
-                                   stream);
+    // Object: custom stream with write method
+    if (typeof stream === 'object' && stream !== null &&
+        typeof stream.write === 'function') {
+      return stream;
+    }
+
+    throw new ERR_INVALID_ARG_TYPE(
+      'options.stream',
+      ['number', 'string', 'Utf8Stream', 'object with write method'],
+      stream,
+    );
   }
 
   handle(record) {
@@ -189,15 +201,15 @@ class JSONConsumer extends LogConsumer {
 class Logger {
   constructor(options = kEmptyObject) {
     validateObject(options, 'options');
-    const {
-      level = 'info',
-      bindings = kEmptyObject,
-    } = options;
+    const { level = 'info', bindings = kEmptyObject } = options;
 
     validateString(level, 'options.level');
     if (!LEVELS[level]) {
-      throw new ERR_INVALID_ARG_VALUE('options.level', level,
-                                      `must be one of: ${LEVEL_NAMES.join(', ')}`);
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.level',
+        level,
+        `must be one of: ${LEVEL_NAMES.join(', ')}`,
+      );
     }
 
     validateObject(bindings, 'options.bindings');
@@ -206,7 +218,6 @@ class Logger {
     this._levelValue = LEVELS[level];
     this._bindings = bindings;
 
-    // Optimize: replace disabled log methods with noop
     this._setLogMethods();
   }
 
@@ -263,7 +274,13 @@ class Logger {
    * @private
    */
   _isError(value) {
-    return ErrorIsError(value);
+    // TODO(@mertcanaltin): Use ErrorIsError from primordials when available
+    // For now, use manual check until ErrorIsError is added to primordials
+
+    return value !== null &&
+           typeof value === 'object' &&
+           (ObjectPrototypeToString(value) === '[object Error]' ||
+           value instanceof Error);
   }
 
   /**
@@ -303,7 +320,7 @@ class Logger {
       };
     } else if (typeof msgOrObj === 'string') {
       msg = msgOrObj;
-      logFields = fields || kEmptyObject;
+      logFields = fields ?? kEmptyObject;
     } else {
       const { msg: extractedMsg, ...restFields } = msgOrObj;
       msg = extractedMsg;
@@ -312,6 +329,10 @@ class Logger {
       if (logFields.err && this._isError(logFields.err)) {
         logFields.err = this._serializeError(logFields.err);
       }
+
+      if (logFields.error && this._isError(logFields.error)) {
+        logFields.error = this._serializeError(logFields.error);
+      }
     }
 
     const record = {

test/parallel/test-log-basic.js

@@ -444,3 +444,57 @@ const path = require('path');
   assert.strictEqual(typeof channels.error, 'object');
   assert.strictEqual(typeof channels.fatal, 'object');
 }
+
+// Test: Support both 'err' and 'error' fields
+{
+  const logs = [];
+  const consumer = new JSONConsumer({
+    stream: {
+      write(data) { logs.push(JSON.parse(data)); },
+      flush() {},
+      flushSync() {},
+      end() {},
+    },
+    level: 'info',
+  });
+  consumer.attach();
+
+  const logger = new Logger({ level: 'info' });
+
+  const err = new Error('Error 1');
+  const error = new Error('Error 2');
+
+  logger.error({ msg: 'Multiple errors', err, error });
+
+  assert.strictEqual(logs.length, 1);
+  assert.strictEqual(logs[0].err.message, 'Error 1');
+  assert.strictEqual(logs[0].error.message, 'Error 2');
+  assert.ok(logs[0].err.stack);
+  assert.ok(logs[0].error.stack);
+}
+
+// Test: 'error' field serialization
+{
+  const logs = [];
+  const consumer = new JSONConsumer({
+    stream: {
+      write(data) { logs.push(JSON.parse(data)); },
+      flush() {},
+      flushSync() {},
+      end() {},
+    },
+    level: 'info',
+  });
+  consumer.attach();
+
+  const logger = new Logger({ level: 'info' });
+  const error = new Error('Test error');
+  error.code = 'TEST_CODE';
+
+  logger.error({ msg: 'Operation failed', error });
+
+  assert.strictEqual(logs.length, 1);
+  assert.strictEqual(logs[0].error.message, 'Test error');
+  assert.strictEqual(logs[0].error.code, 'TEST_CODE');
+  assert.ok(logs[0].error.stack);
+}