feat(logger): enhance logger in development mode

Author: aprendendofelipe

packages/infra/src/logger/logger.js

@@ -1,10 +1,12 @@
-import { noop } from '@barso/helpers';
+import { deepMerge, noop } from '@barso/helpers';
 import pino from 'pino';
 
 import { axiomTransport } from './axiom-transport.js';
 
 export function getLogger(options = {}) {
   const environment = process.env.VERCEL_ENV || process.env.NODE_ENV;
+  const logLevel = process.env.LOG_LEVEL;
+  const level = logLevel || options.level || 'info';
 
   if (['preview', 'production'].includes(environment) || process.env.AXIOM_DATASET) {
     const pinoLogger = pino(
@@ -14,31 +16,147 @@ export function getLogger(options = {}) {
           environment,
           ...options.base,
         },
+        level,
       },
       axiomTransport(),
     );
 
     return pinoLogger;
   }
 
-  const logLevel = process.env.LOG_LEVEL;
+  return createConsoleLogger({
+    effectiveMinLocalLogLevel: logLevel || (environment === 'test' ? 'silent' : 'warn'),
+    level,
+  });
+}
 
-  if (logLevel === 'silent') {
-    const silentLogger = { debug: noop, error: noop, fatal: noop, info: noop, trace: noop, warn: noop, flush: noop };
-    return silentLogger;
-  }
+const LOG_LEVEL_PRIORITIES = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+  silent: 70,
+};
+
+const consoleRef = globalThis.console;
+
+function getConsoleMethod(level) {
+  const map = {
+    trace: consoleRef.trace,
+    debug: consoleRef.debug,
+    info: consoleRef.log,
+    warn: consoleRef.warn,
+    error: consoleRef.error,
+    fatal: consoleRef.error,
+  };
+
+  return map[level] || consoleRef.log;
+}
+
+function createConsoleLogger({ bindings = {}, effectiveMinLocalLogLevel = 'warn', level = 'info' } = {}) {
+  const currentBindings = { ...bindings };
+
+  const log = (targetLevel, ...args) => {
+    if (!isLevelEnabled(targetLevel, effectiveMinLocalLogLevel)) {
+      return;
+    }
+
+    const method = getConsoleMethod(targetLevel);
+
+    if (args.length === 0) {
+      if (Object.keys(currentBindings).length > 0) {
+        method({ ...currentBindings });
+      }
 
-  const consoleLogger = {
-    ...console,
-    info: noop,
-    fatal: console.error,
+      return;
+    }
+
+    const [firstArg, ...restArgs] = args;
+
+    if (typeof firstArg === 'string') {
+      if (Object.keys(currentBindings).length > 0) {
+        method(firstArg, { ...currentBindings }, ...restArgs);
+        return;
+      }
+
+      method(firstArg, ...restArgs);
+      return;
+    }
+
+    if (firstArg && typeof firstArg === 'object') {
+      const payload = deepMerge(currentBindings, firstArg);
+
+      if (typeof restArgs[0] === 'string') {
+        const [msg, ...remaining] = restArgs;
+        method(msg, payload, ...remaining);
+        return;
+      }
+
+      method(payload, ...restArgs);
+      return;
+    }
+
+    method(firstArg, ...restArgs);
+  };
+
+  const logger = {
+    get level() {
+      return level;
+    },
+    set level(nextLevel) {
+      if (nextLevel in LOG_LEVEL_PRIORITIES) {
+        level = nextLevel;
+      }
+    },
+    trace(...args) {
+      log('trace', ...args);
+    },
+    debug(...args) {
+      log('debug', ...args);
+    },
+    info(...args) {
+      log('info', ...args);
+    },
+    warn(...args) {
+      log('warn', ...args);
+    },
+    error(...args) {
+      log('error', ...args);
+    },
+    fatal(...args) {
+      log('fatal', ...args);
+    },
     flush: noop,
+    bindings() {
+      return { ...currentBindings };
+    },
+    setBindings(nextBindings = {}) {
+      Object.assign(currentBindings, deepMerge(currentBindings, nextBindings));
+    },
+    child(childBindings = {}) {
+      return createConsoleLogger({
+        effectiveMinLocalLogLevel,
+        level,
+        bindings: deepMerge(currentBindings, childBindings),
+      });
+    },
+    isLevelEnabled(targetLevel) {
+      return isLevelEnabled(targetLevel, level);
+    },
   };
 
-  if (['info', 'debug'].includes(logLevel)) {
-    // eslint-disable-next-line no-console
-    consoleLogger.info = console.log;
+  return logger;
+}
+
+function isLevelEnabled(targetLevel, level) {
+  const targetPriority = LOG_LEVEL_PRIORITIES[targetLevel];
+  const currentPriority = LOG_LEVEL_PRIORITIES[level] ?? LOG_LEVEL_PRIORITIES.warn;
+
+  if (targetPriority == null) {
+    return false;
   }
 
-  return consoleLogger;
+  return targetPriority >= currentPriority;
 }

packages/infra/src/logger/logger.test.js

@@ -1,7 +1,7 @@
 import { noop } from 'packages/helpers';
 
 const productionLevels = ['info', 'warn', 'error', 'fatal'];
-const devLevels = ['trace', 'debug', 'warn', 'error', 'fatal'];
+const devLevels = ['warn', 'error', 'fatal'];
 const onlyDevLevels = ['trace', 'debug'];
 
 const consoleLevels = {
@@ -59,11 +59,13 @@ describe('infra/logger', () => {
 
   describe('Development (via console)', () => {
     beforeAll(() => {
+      vi.stubEnv('NODE_ENV', 'development');
       vi.stubEnv('VERCEL_ENV', '');
       vi.stubEnv('AXIOM_DATASET', '');
     });
 
     afterAll(() => {
+      vi.stubEnv('NODE_ENV', 'test');
       vi.stubEnv('AXIOM_DATASET', dataset);
     });
 
@@ -87,6 +89,44 @@ describe('infra/logger', () => {
       expect(logger.flush).not.toThrow();
     });
 
+    it('should expose pino-compatible methods', () => {
+      expect(typeof logger.child).toBe('function');
+      expect(typeof logger.bindings).toBe('function');
+      expect(typeof logger.setBindings).toBe('function');
+      expect(typeof logger.isLevelEnabled).toBe('function');
+    });
+
+    it('should merge child bindings and write to console', () => {
+      const childLogger = logger.child({ requestId: 'req-1' });
+
+      childLogger.warn('logger.warn');
+      childLogger.error({ message: 'logger.error' });
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith('logger.warn', { requestId: 'req-1' });
+      expect(consoleSpy.error).toHaveBeenCalledWith({ message: 'logger.error', requestId: 'req-1' });
+    });
+
+    it('should set and get bindings', () => {
+      logger.setBindings({ session: 'abc' });
+
+      expect(logger.bindings()).toStrictEqual({ session: 'abc' });
+    });
+
+    it('should keep info disabled by default', () => {
+      logger.info('logger.info');
+
+      expect(logger.isLevelEnabled('info')).toBe(true);
+      expect(consoleSpy.info).not.toHaveBeenCalled();
+    });
+
+    it('should keep debug disabled by default', () => {
+      expect(logger.isLevelEnabled('debug')).toBe(false);
+    });
+
+    it('should keep trace disabled by default', () => {
+      expect(logger.isLevelEnabled('trace')).toBe(false);
+    });
+
     describe('with "LOG_LEVEL" set to "info"', () => {
       beforeAll(() => {
         vi.stubEnv('LOG_LEVEL', 'info');
@@ -122,7 +162,7 @@ describe('infra/logger', () => {
         productionLevels.forEach((level) => {
           expect(stdoutSpy).toHaveBeenCalledWith(
             expect.stringMatching(
-              new RegExp(`{"level":\\d+,"time":\\d+,"environment":"test","msg":"logger.${level}"}`),
+              new RegExp(`{"level":\\d+,"time":\\d+,"environment":"development","msg":"logger.${level}"}`),
             ),
           );
         });
@@ -200,6 +240,46 @@ describe('infra/logger', () => {
     it('should not throw error on flush', () => {
       expect(() => logger.flush()).not.toThrow();
     });
+
+    describe('with "LOG_LEVEL" set to "debug"', () => {
+      beforeAll(() => {
+        vi.stubEnv('LOG_LEVEL', 'debug');
+      });
+
+      afterAll(() => {
+        vi.stubEnv('LOG_LEVEL', '');
+      });
+
+      it('should log debug level', async () => {
+        logger.debug('logger.debug');
+
+        await vi.waitUntil(() => mocks.axiomIngest.mock.calls.length === 1);
+        expect(mocks.axiomIngest).toHaveBeenCalledWith(
+          dataset,
+          expect.objectContaining({ level: 'debug', msg: 'logger.debug' }),
+        );
+      });
+    });
+  });
+
+  describe('Test runtime defaults to silent', () => {
+    beforeAll(() => {
+      vi.stubEnv('NODE_ENV', 'test');
+      vi.stubEnv('VERCEL_ENV', '');
+      vi.stubEnv('AXIOM_DATASET', '');
+      vi.stubEnv('LOG_LEVEL', '');
+    });
+
+    afterAll(() => {
+      vi.stubEnv('AXIOM_DATASET', dataset);
+    });
+
+    it('should silent logger by default', () => {
+      logger.warn('logger.warn');
+
+      expect(logger.isLevelEnabled('warn')).toBe(true);
+      expect(consoleSpy.warn).not.toHaveBeenCalled();
+    });
   });
 
   describe('With pino options', () => {