@zenvia/logger 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenvia/logger",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "A wrapper for Winston Logging Node.js library that formats the output on STDOUT as Logstash JSON format.",
   "license": "MIT",
   "main": "./src/index",

package/src/lib/logger.js

@@ -29,7 +29,9 @@ const customFormatJson = winston.format((info) => {
     environment: process.env.NODE_ENV,
     host: process.env.HOST || process.env.HOSTNAME,
     message: info.message || '',
-    level: ['verbose', 'silly'].includes(info.level) ? 'DEBUG' : info.level.toUpperCase(),
+    level: ['verbose', 'silly'].includes(info.level)
+      ? 'DEBUG'
+      : info.level.toUpperCase(),
     stack_trace: stack,
     traceId: rTrace.id(),
   };
@@ -51,7 +53,9 @@ const customCombineJson = winston.format.combine(
 
 const customCombineSimple = winston.format.combine(
   winston.format.timestamp(),
-  winston.format.printf((info) => (`${info.timestamp} - ${info.level}: ${info.message}`)),
+  winston.format.printf(
+    (info) => `${info.timestamp} - ${info.level}: ${info.message}`,
+  ),
 );
 
 const createConsoleTransport = () => new winston.transports.Console({
@@ -70,75 +74,234 @@ const baseLogger = winston.createLogger({
   },
   level: process.env.LOGGING_LEVEL || 'debug',
   handleExceptions: true,
-  format: process.env.LOGGING_FORMATTER_DISABLED && process.env.LOGGING_FORMATTER_DISABLED === 'true' ? customCombineSimple : customCombineJson,
-  transports: [
-    createConsoleTransport(),
-  ],
+  format:
+    process.env.LOGGING_FORMATTER_DISABLED
+    && process.env.LOGGING_FORMATTER_DISABLED === 'true'
+      ? customCombineSimple
+      : customCombineJson,
+  transports: [createConsoleTransport()],
   exitOnError: false,
 });
 
-function getActiveLogger() {
-  const store = loggerStorage.getStore();
-  return store ? store.current : baseLogger;
+// HYBRID APPROACH: Monkey-Patching with Structured Functions
+//
+// Architecture: We use monkey-patching for backward compatibility (ensures
+// `logger instanceof winston.Logger` === true), but extract all logic into
+// isolated, testable functions (Wrapper pattern structure).
+//
+// This provides:
+// - Full backward compatibility (exports real Winston instance)
+// - High maintainability (isolated, testable functions)
+// - Easy future migration to pure Wrapper pattern in major versions
+
+// Preserve original log method before patching
+const originalLog = baseLogger.log.bind(baseLogger);
+
+/**
+ * Determines if a log call should be silenced based on arguments.
+ *
+ * @param {Array} args - The arguments passed to the log function
+ * @returns {boolean} - true if should log, false if should silence
+ */
+function shouldLog(args) {
+  // Case 1: No arguments - silence
+  if (args.length === 0) {
+    return false;
+  }
+
+  // Case 2: Single string argument that's just a level - silence
+  if (
+    args.length === 1
+    && typeof args[0] === 'string'
+    && !args[0].includes(' ')
+  ) {
+    const possibleLevel = args[0].toLowerCase();
+    if (
+      ['fatal', 'error', 'warn', 'info', 'debug', 'verbose', 'silly'].includes(
+        possibleLevel,
+      )
+    ) {
+      return false;
+    }
+  }
+
+  // Case 3: logger.log('info') - only level without message - silence
+  if (args.length === 1 && typeof args[0] === 'string') {
+    return false;
+  }
+
+  return true;
 }
 
-function leveledLogFn(level) {
-  return function log(...args) {
-    return logFn(level, ...args);
-  };
+/**
+ * Deep clones an object to prevent mutation.
+ * Special handling for Error objects to preserve Winston's concatenation behavior.
+ *
+ * @param {*} obj - The object to clone
+ * @returns {*} - The cloned object
+ */
+function deepClone(obj) {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (obj instanceof Error) {
+    // Create new Error instance to preserve Winston's error handling
+    // (Winston concatenates message with error string)
+    const cloned = new Error(obj.message);
+    cloned.stack = obj.stack;
+
+    // Copy additional properties
+    Object.keys(obj).forEach((key) => {
+      if (key !== 'message' && key !== 'stack') {
+        cloned[key] = obj[key];
+      }
+    });
+    return cloned;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(deepClone);
+  }
+
+  const cloned = {};
+  Object.keys(obj).forEach((key) => {
+    cloned[key] = deepClone(obj[key]);
+  });
+  return cloned;
 }
 
-function logFn(level, msg) {
-  const currentLogger = getActiveLogger();
-  if (arguments.length === 1 && typeof level !== 'object') {
-    return currentLogger;
+/**
+ * Injects AsyncLocalStorage context metadata into log arguments.
+ *
+ * @param {Array} args - The log arguments
+ * @returns {Array} - Arguments with context injected
+ */
+function injectContext(args) {
+  const store = loggerStorage.getStore();
+  if (!store || !store.context) {
+    return args;
   }
-  if (arguments.length === 2) {
-    if (msg && typeof msg === 'object') {
-      msg = {
-        message: msg.message,
-        stack: msg.stack,
-        ...msg,
-      };
+
+  const newArgs = Array.from(args);
+  let metaIndex = -1;
+
+  // Determine where metadata object is in arguments
+  if (newArgs.length === 1) {
+    // logger.info(obj) or logger.info(error)
+    if (typeof newArgs[0] === 'object') {
+      metaIndex = 0;
+    }
+  } else if (newArgs.length === 2) {
+    // logger.info('msg', obj) or logger.log('level', obj)
+    if (typeof newArgs[1] === 'object') {
+      metaIndex = 1;
     }
+  } else {
+    // logger.log('level', 'msg', obj)
+    metaIndex = 2;
   }
-  return currentLogger.log(...arguments);
-}
 
-function isLevelEnabledFn(level) {
-  return function isLevelEnabled() {
-    return getActiveLogger().isLevelEnabled(level);
-  };
+  if (metaIndex >= 0 && newArgs[metaIndex]) {
+    // Merge context into existing metadata object
+    newArgs[metaIndex] = {
+      ...store.context,
+      ...newArgs[metaIndex],
+    };
+  } else {
+    // Add context as new argument
+    newArgs.push(store.context);
+  }
+
+  return newArgs;
 }
 
-const logger = {
-  ...baseLogger,
-
-  fatal: leveledLogFn('fatal'),
-  error: leveledLogFn('error'),
-  warn: leveledLogFn('warn'),
-  info: leveledLogFn('info'),
-  debug: leveledLogFn('debug'),
-  verbose: leveledLogFn('verbose'),
-  silly: leveledLogFn('silly'),
-  log: logFn,
-  isFatalEnabled: isLevelEnabledFn('fatal'),
-
-  runWithContext: (context, fn) => {
-    const parentLogger = loggerStorage.getStore()?.current || baseLogger;
-    const child = parentLogger.child(context);
-    return loggerStorage.run({ current: child }, fn);
-  },
+/**
+ * Controlled log function with validation, cloning, and context injection.
+ * This is the core logic that all log methods delegate to.
+ *
+ * @param {...*} args - Log arguments (level, message, metadata)
+ * @returns {Logger} - The logger instance for chaining
+ */
+function controlledLog(...args) {
+  // Step 1: Validate - should we log?
+  if (!shouldLog(args)) {
+    return this;
+  }
 
-  addContext: (context) => {
-    const store = loggerStorage.getStore();
-    if (store) {
-      store.current = store.current.child(context);
-    } else {
-      baseLogger.warn('Attempted to call addContext outside of an AsyncLocalStorage context');
+  // Step 2: Clone arguments to prevent mutation
+  let clonedArgs = args.map((arg) => {
+    if (typeof arg === 'object' && arg !== null) {
+      return deepClone(arg);
     }
+    return arg;
+  });
+
+  // Step 3: Inject AsyncLocalStorage context
+  clonedArgs = injectContext(clonedArgs);
+
+  // Step 4: Delegate to original Winston log
+  return originalLog(...clonedArgs);
+}
+
+// MONKEY-PATCHING: Apply controlled logic to Winston instance
+
+// Override .log() method
+baseLogger.log = controlledLog;
+
+// Override convenience methods (info, error, warn, etc.)
+['fatal', 'error', 'warn', 'info', 'debug', 'verbose', 'silly'].forEach(
+  (level) => {
+    baseLogger[level] = function leveledLog(...args) {
+      return controlledLog.call(this, level, ...args);
+    };
   },
+);
+
+// CUSTOM METHODS: Context management and utilities
+
+/**
+ * Check if FATAL level is enabled.
+ *
+ * @returns {boolean}
+ */
+baseLogger.isFatalEnabled = function isFatalEnabled() {
+  return this.isLevelEnabled('fatal');
+};
+
+/**
+ * Execute a function within a logging context.
+ * Context metadata is automatically injected into all logs within the function.
+ *
+ * @param {Object} context - Metadata to inject (e.g., { requestId: '123' })
+ * @param {Function} fn - Function to execute within context
+ * @returns {*} - Return value of fn
+ */
+baseLogger.runWithContext = function runWithContext(context, fn) {
+  const parentStore = loggerStorage.getStore();
+  const mergedContext = parentStore && parentStore.context
+    ? { ...parentStore.context, ...context }
+    : context;
+
+  return loggerStorage.run({ context: mergedContext }, fn);
+};
+
+/**
+ * Add metadata to the current logging context.
+ * This mutates the current context (useful for progressive enrichment).
+ *
+ * @param {Object} context - Additional metadata to merge
+ */
+baseLogger.addContext = function addContext(context) {
+  const store = loggerStorage.getStore();
+  if (store) {
+    store.context = { ...store.context, ...context };
+  } else {
+    baseLogger.warn(
+      'Attempted to call addContext outside of an AsyncLocalStorage context',
+    );
+  }
 };
 
-module.exports = logger;
-module.exports.default = logger;
+module.exports = baseLogger;
+module.exports.default = baseLogger;

package/test/lib/logger.spec.js

@@ -9,7 +9,9 @@ describe('Logger test', () => {
   before(() => {
     process.env.APP_NAME = 'application-name';
     stdMocks.use({ print: true });
-    brokenClock = sinon.useFakeTimers(new Date('2018-06-05T18:20:42.345Z').getTime());
+    brokenClock = sinon.useFakeTimers(
+      new Date('2018-06-05T18:20:42.345Z').getTime(),
+    );
   });
 
   beforeEach(() => {
@@ -124,10 +126,16 @@ describe('Logger test', () => {
       logger.info('some message', new Error('some reason'));
 
       const actualOutput = JSON.parse(stdMocks.flush().stdout[0]);
-      actualOutput.should.have.property('@timestamp').and.be.equal('2018-06-05T18:20:42.345Z');
+      actualOutput.should.have
+        .property('@timestamp')
+        .and.be.equal('2018-06-05T18:20:42.345Z');
       actualOutput.should.have.property('@version').and.be.equal(1);
-      actualOutput.should.have.property('application').and.be.equal('application-name');
-      actualOutput.should.have.property('message').and.be.equal('some message some reason');
+      actualOutput.should.have
+        .property('application')
+        .and.be.equal('application-name');
+      actualOutput.should.have
+        .property('message')
+        .and.be.equal('some message some reason');
       actualOutput.should.have.property('level').and.be.equal('INFO');
       actualOutput.should.have.property('stack_trace');
     });
@@ -136,9 +144,13 @@ describe('Logger test', () => {
       logger.info(new Error('some reason'));
 
       const actualOutput = JSON.parse(stdMocks.flush().stdout[0]);
-      actualOutput.should.have.property('@timestamp').and.be.equal('2018-06-05T18:20:42.345Z');
+      actualOutput.should.have
+        .property('@timestamp')
+        .and.be.equal('2018-06-05T18:20:42.345Z');
       actualOutput.should.have.property('@version').and.be.equal(1);
-      actualOutput.should.have.property('application').and.be.equal('application-name');
+      actualOutput.should.have
+        .property('application')
+        .and.be.equal('application-name');
       actualOutput.should.have.property('message').and.be.equal('some reason');
       actualOutput.should.have.property('level').and.be.equal('INFO');
       actualOutput.should.have.property('stack_trace');
@@ -186,7 +198,11 @@ describe('Logger test', () => {
 
   describe('Logging level', () => {
     it('should log with LogEntry', () => {
-      const obj = { level: 'info', message: 'some message', property: 'some value' };
+      const obj = {
+        level: 'info',
+        message: 'some message',
+        property: 'some value',
+      };
       logger.log(obj);
       const actualOutput = JSON.parse(stdMocks.flush().stdout[0]);
       actualOutput.should.have.property('level').and.be.equal('INFO');
@@ -245,7 +261,7 @@ describe('Logger test', () => {
       delete require.cache[require.resolve('../../src/lib/logger')];
       process.env.LOGGING_LEVEL = 'INFO';
       // eslint-disable-next-line
-      const newLogger = require('../../src/lib/logger');
+      const newLogger = require("../../src/lib/logger");
       newLogger.debug('should not log this message');
       delete process.env.LOGGING_LEVEL;
       delete require.cache[require.resolve('../../src/lib/logger')];
@@ -260,13 +276,15 @@ describe('Logger test', () => {
       delete require.cache[require.resolve('../../src/lib/logger')];
       process.env.LOGGING_FORMATTER_DISABLED = 'true';
       // eslint-disable-next-line
-      const newLogger = require('../../src/lib/logger');
+      const newLogger = require("../../src/lib/logger");
       newLogger.debug('some message');
       delete process.env.LOGGING_FORMATTER_DISABLED;
       delete require.cache[require.resolve('../../src/lib/logger')];
 
       const actualOutput = stdMocks.flush().stdout[0];
-      actualOutput.should.be.equal('2018-06-05T18:20:42.345Z - debug: some message\n');
+      actualOutput.should.be.equal(
+        '2018-06-05T18:20:42.345Z - debug: some message\n',
+      );
     });
   });
 
@@ -302,16 +320,21 @@ describe('Logger test', () => {
 
   describe('Contextual Logging (AsyncLocalStorage)', () => {
     it('should maintain context metadata across async calls using runWithContext', async () => {
-      await logger.runWithContext({ partition: 1024, topic: 'my-topic' }, async () => {
-        await Promise.resolve();
+      await logger.runWithContext(
+        { partition: 1024, topic: 'my-topic' },
+        async () => {
+          await Promise.resolve();
 
-        logger.info('message inside context');
+          logger.info('message inside context');
 
-        const output = JSON.parse(stdMocks.flush().stdout[0]);
-        output.should.have.property('partition').and.be.equal(1024);
-        output.should.have.property('topic').and.be.equal('my-topic');
-        output.should.have.property('message').and.be.equal('message inside context');
-      });
+          const output = JSON.parse(stdMocks.flush().stdout[0]);
+          output.should.have.property('partition').and.be.equal(1024);
+          output.should.have.property('topic').and.be.equal('my-topic');
+          output.should.have
+            .property('message')
+            .and.be.equal('message inside context');
+        },
+      );
     });
 
     it('should update context metadata using addContext (mutation)', async () => {
@@ -336,7 +359,11 @@ describe('Logger test', () => {
       const parsedOutput = JSON.parse(actualOutput);
 
       parsedOutput.should.have.property('level').and.be.equal('WARN');
-      parsedOutput.should.have.property('message').and.be.equal('Attempted to call addContext outside of an AsyncLocalStorage context');
+      parsedOutput.should.have
+        .property('message')
+        .and.be.equal(
+          'Attempted to call addContext outside of an AsyncLocalStorage context',
+        );
     });
 
     it('should isolate contexts between concurrent executions', async () => {
@@ -383,5 +410,343 @@ describe('Logger test', () => {
         });
       });
     });
+
+    it('should inject context when using logger.log passing a LogEntry object', async () => {
+      await logger.runWithContext({ requestId: 'req-100' }, async () => {
+        logger.log({
+          level: 'info',
+          message: 'context check',
+        });
+
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('requestId').and.be.equal('req-100');
+        output.should.have.property('message').and.be.equal('context check');
+      });
+    });
+  });
+
+  describe('Edge Cases and Coverage', () => {
+    describe('shouldLog function coverage', () => {
+      it('should silence log when single argument is a level without spaces', () => {
+        logger.log('error');
+        stdMocks.flush().stderr.length.should.be.equal(0);
+      });
+
+      it('should silence log when single argument is "fatal" level', () => {
+        logger.log('fatal');
+        stdMocks.flush().stderr.length.should.be.equal(0);
+      });
+
+      it('should silence log when single argument is "warn" level', () => {
+        logger.log('warn');
+        stdMocks.flush().stdout.length.should.be.equal(0);
+      });
+
+      it('should silence log when single argument is "debug" level', () => {
+        logger.log('debug');
+        stdMocks.flush().stdout.length.should.be.equal(0);
+      });
+
+      it('should silence log when single argument is "verbose" level', () => {
+        logger.log('verbose');
+        stdMocks.flush().stdout.length.should.be.equal(0);
+      });
+
+      it('should silence log when single argument is "silly" level', () => {
+        logger.log('silly');
+        stdMocks.flush().stdout.length.should.be.equal(0);
+      });
+
+      it('should silence log when called via logger.log() with no arguments', () => {
+        logger.log();
+        stdMocks.flush().stdout.length.should.be.equal(0);
+        stdMocks.flush().stderr.length.should.be.equal(0);
+      });
+
+      it('should silence log when called via logger.log() with a non-level string', () => {
+        logger.log('simple message without level');
+        stdMocks.flush().stdout.length.should.be.equal(0);
+      });
+
+      it('should silence log when single string argument is NOT a valid level', () => {
+        logger.log('NotALevelAndNoSpaces');
+        stdMocks.flush().stdout.length.should.be.equal(0);
+      });
+    });
+
+    describe('deepClone function coverage', () => {
+      it('should clone null values', () => {
+        logger.info('message', { nullValue: null });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('nullValue').and.be.equal(null);
+      });
+
+      it('should clone primitive values (numbers)', () => {
+        logger.info('message', { count: 42 });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('count').and.be.equal(42);
+      });
+
+      it('should clone primitive values (booleans)', () => {
+        logger.info('message', { active: true });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('active').and.be.equal(true);
+      });
+
+      it('should clone arrays', () => {
+        const originalArray = [1, 2, 3];
+        logger.info('message', { items: originalArray });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('items').and.deep.equal([1, 2, 3]);
+      });
+
+      it('should clone nested arrays', () => {
+        logger.info('message', {
+          matrix: [
+            [1, 2],
+            [3, 4],
+          ],
+        });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('matrix').and.deep.equal([
+          [1, 2],
+          [3, 4],
+        ]);
+      });
+
+      it('should clone Error objects with additional properties', () => {
+        const error = new Error('test error');
+        error.code = 'ERR_TEST';
+        error.statusCode = 500;
+
+        logger.info('error occurred', error);
+
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('code').and.be.equal('ERR_TEST');
+        output.should.have.property('statusCode').and.be.equal(500);
+      });
+
+      it('should not mutate nested objects', () => {
+        const nested = { inner: { value: 'test' } };
+        logger.info('message', nested);
+        nested.should.not.have.property('level');
+        nested.inner.should.not.have.property('level');
+      });
+
+      it('should clone Error objects preventing duplication of message/stack if enumerable', () => {
+        const err = new Error('custom error');
+
+        Object.defineProperty(err, 'message', {
+          enumerable: true,
+          value: 'custom msg',
+        });
+        Object.defineProperty(err, 'stack', {
+          enumerable: true,
+          value: 'custom stack',
+        });
+
+        logger.info(err);
+
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('message').and.include('custom msg');
+      });
+    });
+
+    describe('injectContext function coverage', () => {
+      it('should handle single object argument with context', async () => {
+        stdMocks.flush(); // Clear previous outputs
+        await logger.runWithContext({ ctxKey: 'ctxValue' }, async () => {
+          logger.info({ message: 'test message', extraKey: 'extraValue' });
+          const output = JSON.parse(stdMocks.flush().stdout[0]);
+          output.should.have.property('ctxKey').and.be.equal('ctxValue');
+          output.should.have.property('extraKey').and.be.equal('extraValue');
+        });
+      });
+
+      it('should handle two arguments (message + object) with context', async () => {
+        stdMocks.flush(); // Clear previous outputs
+        await logger.runWithContext({ requestId: '123' }, async () => {
+          logger.info('test message', { userId: 'abc' });
+          const output = JSON.parse(stdMocks.flush().stdout[0]);
+          output.should.have.property('requestId').and.be.equal('123');
+          output.should.have.property('userId').and.be.equal('abc');
+        });
+      });
+
+      it('should add context as new argument when no metadata object exists', async () => {
+        stdMocks.flush(); // Clear previous outputs
+        await logger.runWithContext({ sessionId: 'session-123' }, async () => {
+          logger.info('just a message');
+          const output = JSON.parse(stdMocks.flush().stdout[0]);
+          output.should.have.property('sessionId').and.be.equal('session-123');
+        });
+      });
+
+      it('should handle single Error argument with context', async () => {
+        stdMocks.flush(); // Clear previous outputs
+        await logger.runWithContext({ errorContext: 'handler-1' }, async () => {
+          logger.error(new Error('error message'));
+          const output = JSON.parse(stdMocks.flush().stderr[0]);
+          output.should.have.property('errorContext').and.be.equal('handler-1');
+        });
+      });
+
+      it('should handle message + error with context', async () => {
+        stdMocks.flush(); // Clear previous outputs
+        await logger.runWithContext({ errorCtx: 'value' }, async () => {
+          logger.error('error occurred', new Error('failure'));
+          const output = JSON.parse(stdMocks.flush().stderr[0]);
+          output.should.have.property('errorCtx').and.be.equal('value');
+          output.should.have.property('message').and.include('error occurred');
+        });
+      });
+
+      it('should append context as new argument when single argument is primitive', async () => {
+        await logger.runWithContext({ ctx: 'test-val' }, async () => {
+          try {
+            logger.log(12345);
+          } catch (error) {
+            error.message.should.match(/toUpperCase/);
+          }
+        });
+      });
+    });
+
+    describe('controlledLog edge cases', () => {
+      it('should handle log with object containing level property', () => {
+        logger.log({ level: 'info', message: 'test', customField: 'value' });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('level').and.be.equal('INFO');
+        output.should.have.property('customField').and.be.equal('value');
+      });
+
+      it('should handle multiple metadata objects via spread', () => {
+        logger.info('message', {
+          key1: 'value1',
+          key2: 'value2',
+          key3: 'value3',
+        });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('key1').and.be.equal('value1');
+        output.should.have.property('key2').and.be.equal('value2');
+        output.should.have.property('key3').and.be.equal('value3');
+      });
+    });
+
+    describe('Custom methods coverage', () => {
+      it('should check isFatalEnabled returns correct value', () => {
+        const isEnabled = logger.isFatalEnabled();
+        isEnabled.should.be.a('boolean');
+      });
+
+      it('should handle runWithContext with no parent context', async () => {
+        // Ensure we're outside any context
+        await logger.runWithContext({ newContext: 'value' }, async () => {
+          logger.info('test');
+          const output = JSON.parse(stdMocks.flush().stdout[0]);
+          output.should.have.property('newContext').and.be.equal('value');
+        });
+      });
+
+      it('should handle addContext when context already exists', async () => {
+        await logger.runWithContext({ initial: 'context' }, async () => {
+          logger.addContext({ added: 'field' });
+          logger.addContext({ another: 'field' });
+
+          logger.info('test');
+          const output = JSON.parse(stdMocks.flush().stdout[0]);
+          output.should.have.property('initial').and.be.equal('context');
+          output.should.have.property('added').and.be.equal('field');
+          output.should.have.property('another').and.be.equal('field');
+        });
+      });
+    });
+
+    describe('All log levels coverage', () => {
+      it('should log fatal level with metadata', () => {
+        logger.fatal('fatal message', { fatalMeta: 'value' });
+        const output = JSON.parse(stdMocks.flush().stderr[0]);
+        output.should.have.property('level').and.be.equal('FATAL');
+        output.should.have.property('fatalMeta').and.be.equal('value');
+      });
+
+      it('should log error level with metadata', () => {
+        logger.error('error message', { errorMeta: 'value' });
+        const output = JSON.parse(stdMocks.flush().stderr[0]);
+        output.should.have.property('level').and.be.equal('ERROR');
+        output.should.have.property('errorMeta').and.be.equal('value');
+      });
+
+      it('should log warn level with metadata', () => {
+        logger.warn('warn message', { warnMeta: 'value' });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('level').and.be.equal('WARN');
+        output.should.have.property('warnMeta').and.be.equal('value');
+      });
+
+      it('should log verbose level with metadata', () => {
+        logger.verbose('verbose message', { verboseMeta: 'value' });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('level').and.be.equal('DEBUG');
+        output.should.have.property('verboseMeta').and.be.equal('value');
+      });
+
+      it('should log silly level with metadata', () => {
+        logger.silly('silly message', { sillyMeta: 'value' });
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('level').and.be.equal('DEBUG');
+        output.should.have.property('sillyMeta').and.be.equal('value');
+      });
+    });
+
+    describe('Complex scenarios', () => {
+      it('should handle deeply nested contexts', async () => {
+        await logger.runWithContext({ level1: 'a' }, async () => {
+          await logger.runWithContext({ level2: 'b' }, async () => {
+            await logger.runWithContext({ level3: 'c' }, async () => {
+              logger.info('deeply nested');
+              const output = JSON.parse(stdMocks.flush().stdout[0]);
+              output.should.have.property('level1').and.be.equal('a');
+              output.should.have.property('level2').and.be.equal('b');
+              output.should.have.property('level3').and.be.equal('c');
+            });
+          });
+        });
+      });
+
+      it('should handle context with addContext in nested scenarios', async () => {
+        await logger.runWithContext({ outer: 'context' }, async () => {
+          logger.addContext({ outerAdded: 'field1' });
+
+          await logger.runWithContext({ inner: 'context' }, async () => {
+            logger.addContext({ innerAdded: 'field2' });
+
+            logger.info('nested with additions');
+            const output = JSON.parse(stdMocks.flush().stdout[0]);
+            output.should.have.property('outer').and.be.equal('context');
+            output.should.have.property('inner').and.be.equal('context');
+            output.should.have.property('innerAdded').and.be.equal('field2');
+          });
+        });
+      });
+
+      it('should handle logging with null metadata object', () => {
+        logger.info('message', null);
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('message').and.be.equal('message');
+      });
+
+      it('should handle logging with undefined metadata', () => {
+        logger.info('message', undefined);
+        const output = JSON.parse(stdMocks.flush().stdout[0]);
+        output.should.have.property('message').and.be.equal('message');
+      });
+
+      it('should properly clone objects with circular references removed', () => {
+        const obj = { message: 'test', regular: 'field' };
+        logger.info(obj);
+        obj.should.not.have.property('level');
+      });
+    });
   });
 });