autotel 4.0.0 → 4.2.0

package/src/autotel-logger.test.ts

@@ -1,548 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  createBuiltinLogger,
-  autotelLogger,
-  runWithLogLevel,
-  getActiveLogLevel,
-  getTraceContext,
-} from './autotel-logger';
-import { trace } from '@opentelemetry/api';
-
-describe('Built-in Logger', () => {
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore();
-  });
-
-  describe('createBuiltinLogger', () => {
-    it('should create a logger with service name', () => {
-      const logger = createBuiltinLogger('test-service');
-      expect(logger).toBeDefined();
-      expect(logger.info).toBeDefined();
-      expect(logger.error).toBeDefined();
-      expect(logger.warn).toBeDefined();
-      expect(logger.debug).toBeDefined();
-    });
-
-    it('should log info messages with service name', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.info({ key: 'value' }, 'test message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'info',
-        service: 'test-service',
-        msg: 'test message',
-        key: 'value',
-      });
-      expect(logOutput.timestamp).toBeDefined();
-    });
-
-    it('should log error messages with Error object', () => {
-      const logger = createBuiltinLogger('test-service');
-      const error = new Error('test error');
-      logger.error({ err: error }, 'error occurred');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'error',
-        service: 'test-service',
-        msg: 'error occurred',
-        error: 'test error',
-      });
-      expect(logOutput.stack).toBeDefined();
-    });
-
-    it('should log error messages without Error object', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.error({}, 'error occurred');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'error',
-        service: 'test-service',
-        msg: 'error occurred',
-      });
-      expect(logOutput.error).toBeUndefined();
-    });
-
-    it('should log warning messages', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.warn({ reason: 'test' }, 'warning message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'warn',
-        service: 'test-service',
-        msg: 'warning message',
-        reason: 'test',
-      });
-    });
-
-    it('should log debug messages when level is set to debug', () => {
-      const logger = createBuiltinLogger('test-service', { level: 'debug' });
-      logger.debug({ detail: 'verbose' }, 'debug message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'debug',
-        service: 'test-service',
-        msg: 'debug message',
-        detail: 'verbose',
-      });
-    });
-
-    it('should not log debug messages when level is info (default)', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.debug({ detail: 'verbose' }, 'debug message');
-
-      expect(consoleLogSpy).not.toHaveBeenCalled();
-    });
-
-    it('should include trace context when available', () => {
-      const logger = createBuiltinLogger('test-service');
-
-      // Create a mock span
-      const mockSpan = {
-        spanContext: () => ({
-          traceId: 'test-trace-id-16chars',
-          spanId: 'test-span-id',
-          traceFlags: 1,
-        }),
-        setAttribute: vi.fn(),
-        setStatus: vi.fn(),
-        recordException: vi.fn(),
-        end: vi.fn(),
-        isRecording: () => true,
-        updateName: vi.fn(),
-        addEvent: vi.fn(),
-        setAttributes: vi.fn(),
-      };
-
-      // Mock trace.getActiveSpan to return our span
-      const getActiveSpanSpy = vi
-        .spyOn(trace, 'getActiveSpan')
-        .mockReturnValue(mockSpan as any);
-
-      logger.info({}, 'message with trace');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'info',
-        service: 'test-service',
-        msg: 'message with trace',
-        traceId: 'test-trace-id-16chars',
-        spanId: 'test-span-id',
-        correlationId: 'test-trace-id-16',
-      });
-
-      getActiveSpanSpy.mockRestore();
-    });
-
-    it('should handle non-Error objects in error() as extra context', () => {
-      const logger = createBuiltinLogger('test-service');
-      const errorContext = { code: 'ERR_SIMPLE', details: 'simple error' };
-      // Pino style: (extra, message) - extra is preserved as structured context
-      logger.error(errorContext, 'error occurred');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'error',
-        service: 'test-service',
-        msg: 'error occurred',
-        code: 'ERR_SIMPLE',
-        details: 'simple error',
-      });
-    });
-
-    it('should accept a single context object', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.info({ a: 1, b: 2, c: 3 }, 'message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'info',
-        msg: 'message',
-        a: 1,
-        b: 2,
-        c: 3,
-      });
-    });
-
-    it('should preserve timestamp format', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.info({}, 'test');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput.timestamp).toMatch(
-        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
-      );
-    });
-
-    it('should support string-only calls (Pino-style)', () => {
-      const logger = createBuiltinLogger('test-service');
-      logger.info('simple message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      expect(logOutput).toMatchObject({
-        level: 'info',
-        service: 'test-service',
-        msg: 'simple message',
-      });
-    });
-
-    it('should auto-swap legacy Winston-style (message, metadata) to preserve data', () => {
-      const logger = createBuiltinLogger('test-service');
-      const consoleWarnSpy = vi
-        .spyOn(console, 'warn')
-        .mockImplementation(() => {});
-
-      // Legacy Winston-style: (message, metadata)
-      // @ts-expect-error - testing legacy pattern
-      logger.info('User created', { userId: '123', action: 'create' });
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      // Metadata should be preserved (auto-swapped)
-      expect(logOutput).toMatchObject({
-        level: 'info',
-        service: 'test-service',
-        msg: 'User created',
-        userId: '123',
-        action: 'create',
-      });
-
-      // Warning should be logged in development
-      expect(consoleWarnSpy).toHaveBeenCalledOnce();
-      expect(consoleWarnSpy.mock.calls[0][0]).toContain(
-        'Legacy logger pattern',
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should auto-swap legacy Winston-style for error() and preserve err object', () => {
-      const logger = createBuiltinLogger('test-service');
-      const consoleWarnSpy = vi
-        .spyOn(console, 'warn')
-        .mockImplementation(() => {});
-      const error = new Error('test error');
-
-      // Legacy Winston-style: (message, { err })
-      // @ts-expect-error - testing legacy pattern
-      logger.error('Operation failed', { err: error, context: 'test' });
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      // Metadata should be preserved and err should be extracted
-      expect(logOutput).toMatchObject({
-        level: 'error',
-        service: 'test-service',
-        msg: 'Operation failed',
-        error: 'test error',
-        context: 'test',
-      });
-      expect(logOutput.stack).toBeDefined();
-
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should auto-swap legacy logger.error(message, error) pattern', () => {
-      const logger = createBuiltinLogger('test-service');
-      const consoleWarnSpy = vi
-        .spyOn(console, 'warn')
-        .mockImplementation(() => {});
-      const error = new Error('database connection failed');
-
-      // Very common legacy pattern: logger.error('msg', error)
-      // @ts-expect-error - testing legacy pattern
-      logger.error('Operation failed', error);
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-
-      // Error should be preserved with stack trace
-      expect(logOutput).toMatchObject({
-        level: 'error',
-        service: 'test-service',
-        msg: 'Operation failed',
-        error: 'database connection failed',
-        name: 'Error',
-      });
-      expect(logOutput.stack).toBeDefined();
-      expect(logOutput.stack).toContain('Error: database connection failed');
-
-      // Warning should be logged in development
-      expect(consoleWarnSpy).toHaveBeenCalledOnce();
-      expect(consoleWarnSpy.mock.calls[0][0]).toContain(
-        "logger.error('message', error)",
-      );
-
-      consoleWarnSpy.mockRestore();
-    });
-  });
-
-  describe('Pretty mode', () => {
-    it('should format logs in pretty mode', () => {
-      const logger = createBuiltinLogger('test-service', { pretty: true });
-      logger.info({ key: 'value' }, 'pretty message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = consoleLogSpy.mock.calls[0][0];
-
-      // In pretty mode, output is a formatted string, not JSON
-      expect(typeof logOutput).toBe('string');
-      expect(logOutput).toContain('INFO');
-      expect(logOutput).toContain('test-service');
-      expect(logOutput).toContain('pretty message');
-    });
-
-    it('should format errors in pretty mode', () => {
-      const logger = createBuiltinLogger('test-service', { pretty: true });
-      const error = new Error('test error');
-      logger.error({ err: error }, 'error occurred');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = consoleLogSpy.mock.calls[0][0];
-
-      expect(typeof logOutput).toBe('string');
-      expect(logOutput).toContain('ERROR');
-      expect(logOutput).toContain('test-service');
-      expect(logOutput).toContain('error occurred');
-    });
-  });
-
-  describe('Edge cases', () => {
-    it('should throw on circular references in context', () => {
-      const logger = createBuiltinLogger('test-service');
-      const circular: Record<string, unknown> = { a: 1 };
-      circular.self = circular;
-
-      // JSON.stringify will throw on circular references
-      expect(() => {
-        logger.info(circular, 'circular');
-      }).toThrow(/circular/i);
-    });
-
-    it('should handle very long messages', () => {
-      const logger = createBuiltinLogger('test-service');
-      const longMessage = 'a'.repeat(10_000);
-
-      logger.info({}, longMessage);
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-      expect(logOutput.msg).toBe(longMessage);
-    });
-
-    it('should handle special characters in messages', () => {
-      const logger = createBuiltinLogger('test-service');
-      const specialMessage = 'Hello\nWorld\t"quoted"\r\nNew Line';
-
-      logger.info({}, specialMessage);
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-      expect(logOutput.msg).toBe(specialMessage);
-    });
-  });
-
-  describe('Dynamic log level control', () => {
-    it('should override log level via runWithLogLevel', () => {
-      const logger = createBuiltinLogger('test-service', { level: 'info' });
-
-      // Normal behavior: debug filtered out
-      logger.debug({}, 'outside context');
-      expect(consoleLogSpy).not.toHaveBeenCalled();
-
-      // Inside debug context: debug logged
-      runWithLogLevel('debug', () => {
-        logger.debug({}, 'inside debug context');
-      });
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-
-      // Back to normal: debug filtered out again
-      logger.debug({}, 'outside context again');
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-    });
-
-    it('should support none level to temporarily disable logging', () => {
-      const logger = createBuiltinLogger('test-service', { level: 'info' });
-
-      logger.info({}, 'before none');
-      const callsBeforeNone = consoleLogSpy.mock.calls.length;
-
-      runWithLogLevel('none', () => {
-        logger.info({}, 'inside none context');
-        logger.error({}, 'even errors suppressed');
-      });
-      expect(consoleLogSpy.mock.calls.length).toBe(callsBeforeNone); // No new logs
-
-      logger.info({}, 'after none');
-      expect(consoleLogSpy.mock.calls.length).toBe(callsBeforeNone + 1);
-    });
-
-    it('should return value from callback', () => {
-      const result = runWithLogLevel('debug', () => {
-        return 42;
-      });
-      expect(result).toBe(42);
-    });
-
-    it('should propagate async results', async () => {
-      const result = await runWithLogLevel('debug', async () => {
-        return 'async value';
-      });
-      expect(result).toBe('async value');
-    });
-
-    it('should allow raising log level temporarily', () => {
-      const logger = createBuiltinLogger('test-service', { level: 'error' });
-
-      logger.info({}, 'normal info');
-      logger.warn({}, 'normal warn');
-      expect(consoleLogSpy).not.toHaveBeenCalled();
-
-      runWithLogLevel('info', () => {
-        logger.info({}, 'temporary info');
-        logger.warn({}, 'temporary warn');
-      });
-      expect(consoleLogSpy).toHaveBeenCalledTimes(2);
-    });
-
-    it('should isolate log level changes to context', () => {
-      const logger = createBuiltinLogger('test-service', { level: 'info' });
-
-      runWithLogLevel('debug', () => {
-        logger.debug({}, 'context 1 - debug');
-        expect(consoleLogSpy).toHaveBeenCalledOnce();
-      });
-
-      runWithLogLevel('error', () => {
-        logger.info({}, 'context 2 - info should be filtered');
-        expect(consoleLogSpy).toHaveBeenCalledOnce(); // No new logs
-      });
-    });
-  });
-
-  describe('getActiveLogLevel', () => {
-    it('should return undefined when no active level', () => {
-      expect(getActiveLogLevel()).toBeUndefined();
-    });
-
-    it('should return active level inside runWithLogLevel', () => {
-      runWithLogLevel('debug', () => {
-        expect(getActiveLogLevel()).toBe('debug');
-      });
-
-      runWithLogLevel('error', () => {
-        expect(getActiveLogLevel()).toBe('error');
-      });
-    });
-
-    it('should reset after runWithLogLevel completes', () => {
-      runWithLogLevel('debug', () => {
-        expect(getActiveLogLevel()).toBe('debug');
-      });
-      expect(getActiveLogLevel()).toBeUndefined();
-    });
-  });
-
-  describe('getTraceContext', () => {
-    it('should return null when no active span', () => {
-      expect(getTraceContext()).toBeNull();
-    });
-
-    it('should return trace context when span is active', () => {
-      const mockSpan = {
-        spanContext: () => ({
-          traceId: 'abcdef1234567890abcdef1234567890',
-          spanId: 'abcdef1234567890',
-          traceFlags: 1,
-        }),
-        setAttribute: vi.fn(),
-        setStatus: vi.fn(),
-        recordException: vi.fn(),
-        end: vi.fn(),
-        isRecording: () => true,
-        updateName: vi.fn(),
-        addEvent: vi.fn(),
-        setAttributes: vi.fn(),
-      };
-
-      const getActiveSpanSpy = vi
-        .spyOn(trace, 'getActiveSpan')
-        .mockReturnValue(mockSpan as any);
-
-      const ctx = getTraceContext();
-
-      expect(ctx).toEqual({
-        traceId: 'abcdef1234567890abcdef1234567890',
-        spanId: 'abcdef1234567890',
-        correlationId: 'abcdef1234567890', // First 16 chars of traceId
-      });
-
-      getActiveSpanSpy.mockRestore();
-    });
-  });
-
-  describe('autotelLogger', () => {
-    it('should create a logger with default service name', () => {
-      const logger = autotelLogger();
-      expect(logger).toBeDefined();
-      expect(logger.info).toBeDefined();
-      expect(logger.error).toBeDefined();
-      expect(logger.warn).toBeDefined();
-      expect(logger.debug).toBeDefined();
-    });
-
-    it('should create a logger with custom options', () => {
-      const logger = autotelLogger({
-        service: 'custom-service',
-        level: 'debug',
-        pretty: false,
-      });
-      logger.info({}, 'test message');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-      expect(logOutput.service).toBe('custom-service');
-    });
-
-    it('should use default service name "app" when not provided', () => {
-      const logger = autotelLogger();
-      logger.info({}, 'test');
-
-      expect(consoleLogSpy).toHaveBeenCalledOnce();
-      const logOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-      expect(logOutput.service).toBe('app');
-    });
-  });
-});