feat: Add better common logger support.

kinyoklion · kinyoklion · commit e551293794a2 · 2024-10-31T16:11:23.000-07:00
diff --git a/packages/shared/common/__tests__/logging/BasicLogger.test.ts b/packages/shared/common/__tests__/logging/BasicLogger.test.ts
@@ -2,6 +2,10 @@ import { BasicLogger, LDLogLevel } from '../../src';
 
 const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
 
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
 describe.each<[LDLogLevel, string[]]>([
   [
     'debug',
@@ -64,10 +68,6 @@ describe('given a logger with a custom name', () => {
 describe('given a default logger', () => {
   const logger = new BasicLogger({});
 
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
   it('logs to the console', () => {
     logger.warn('potato', 'bacon');
     expect(spy).toHaveBeenCalledWith('potato', 'bacon');
@@ -81,10 +81,6 @@ describe('given a logger with a destination that throws', () => {
     },
   });
 
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
   it('logs to the console instead of throwing', () => {
     logger.error('a');
     expect(spy).toHaveBeenCalledWith('error: [LaunchDarkly] a');
@@ -94,10 +90,6 @@ describe('given a logger with a destination that throws', () => {
 describe('given a logger with a formatter that throws', () => {
   const strings: string[] = [];
 
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
   const logger = new BasicLogger({
     destination: (...args: any) => {
       strings.push(args.join(' '));
@@ -112,3 +104,102 @@ describe('given a logger with a formatter that throws', () => {
     expect(spy).toHaveBeenCalledTimes(0);
   });
 });
+
+it('dispatches logs correctly with multiple destinations', () => {
+  const debug = jest.fn();
+  const info = jest.fn();
+  const warn = jest.fn();
+  const error = jest.fn();
+
+  const logger = new BasicLogger({
+    destination: {
+      debug,
+      info,
+      warn,
+      error,
+    },
+    level: 'debug',
+  });
+
+  logger.debug('toDebug');
+  logger.info('toInfo');
+  logger.warn('toWarn');
+  logger.error('toError');
+
+  expect(debug).toHaveBeenCalledTimes(1);
+  expect(debug).toHaveBeenCalledWith('debug: [LaunchDarkly] toDebug');
+
+  expect(info).toHaveBeenCalledTimes(1);
+  expect(info).toHaveBeenCalledWith('info: [LaunchDarkly] toInfo');
+
+  expect(warn).toHaveBeenCalledTimes(1);
+  expect(warn).toHaveBeenCalledWith('warn: [LaunchDarkly] toWarn');
+
+  expect(error).toHaveBeenCalledTimes(1);
+  expect(error).toHaveBeenCalledWith('error: [LaunchDarkly] toError');
+});
+
+it('handles destinations which throw', () => {
+  const debug = jest.fn(() => {
+    throw new Error('bad');
+  });
+  const info = jest.fn(() => {
+    throw new Error('bad');
+  });
+  const warn = jest.fn(() => {
+    throw new Error('bad');
+  });
+  const error = jest.fn(() => {
+    throw new Error('bad');
+  });
+
+  const logger = new BasicLogger({
+    destination: {
+      debug,
+      info,
+      warn,
+      error,
+    },
+    level: 'debug',
+  });
+
+  logger.debug('toDebug');
+  logger.info('toInfo');
+  logger.warn('toWarn');
+  logger.error('toError');
+
+  expect(spy).toHaveBeenCalledTimes(4);
+  expect(spy).toHaveBeenCalledWith('debug: [LaunchDarkly] toDebug');
+  expect(spy).toHaveBeenCalledWith('info: [LaunchDarkly] toInfo');
+  expect(spy).toHaveBeenCalledWith('warn: [LaunchDarkly] toWarn');
+  expect(spy).toHaveBeenCalledWith('error: [LaunchDarkly] toError');
+});
+
+it('handles destinations which are not defined', () => {
+  const debug = jest.fn();
+  const info = jest.fn();
+  const logger = new BasicLogger({
+    // @ts-ignore
+    destination: {
+      debug,
+      info,
+    },
+    level: 'debug',
+  });
+
+  logger.debug('toDebug');
+  logger.info('toInfo');
+  logger.warn('toWarn');
+  logger.error('toError');
+
+  expect(debug).toHaveBeenCalledTimes(1);
+  expect(debug).toHaveBeenCalledWith('debug: [LaunchDarkly] toDebug');
+
+  expect(info).toHaveBeenCalledTimes(1);
+  expect(info).toHaveBeenCalledWith('info: [LaunchDarkly] toInfo');
+
+  expect(spy).toHaveBeenCalledTimes(2);
+
+  expect(spy).toHaveBeenCalledWith('toWarn');
+  expect(spy).toHaveBeenCalledWith('toError');
+});
diff --git a/packages/shared/common/src/api/logging/BasicLoggerOptions.ts b/packages/shared/common/src/api/logging/BasicLoggerOptions.ts
@@ -21,18 +21,23 @@ export interface BasicLoggerOptions {
   name?: string;
 
   /**
-   * An optional function to use to print each log line.
+   * An optional function, or collection of functions to use to print each log line.
    *
-   * If this is specified, `basicLogger` calls it to write each line of output. The
+   * If not specified, the default is `console.error`.
+   *
+   * If a function is specified, `basicLogger` calls it to write each line of output. The
    * argument is a fully formatted log line, not including a linefeed. The function
    * is only called for log levels that are enabled.
    *
-   * If not specified, the default is `console.error`.
+   * If a map is specified, then each entry will be used as the destination for the corresponding
+   * log level. Any level that is not specified will use the default of `console.error`.
    *
    * Setting this property to anything other than a function will cause SDK
    * initialization to fail.
    */
-  destination?: (line: string) => void;
+  destination?:
+    | ((line: string) => void)
+    | Record<'debug' | 'info' | 'warn' | 'error', (line: string) => void>;
 
   /**
    * An optional formatter to use. The formatter should be compatible
diff --git a/packages/shared/common/src/logging/BasicLogger.ts b/packages/shared/common/src/logging/BasicLogger.ts
@@ -1,15 +1,15 @@
-import { BasicLoggerOptions, LDLogger } from '../api';
+import { BasicLoggerOptions, LDLogger, LDLogLevel } from '../api';
 import format from './format';
 
-const LogPriority = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  none: 4,
-};
+enum LogPriority {
+  debug = 0,
+  info = 1,
+  warn = 2,
+  error = 3,
+  none = 4,
+}
 
-const LevelNames = ['debug', 'info', 'warn', 'error', 'none'];
+const LEVEL_NAMES: LDLogLevel[] = ['debug', 'info', 'warn', 'error', 'none'];
 
 /**
  * A basic logger which handles filtering by level.
@@ -27,7 +27,7 @@ export default class BasicLogger implements LDLogger {
 
   private _name: string;
 
-  private _destination?: (line: string) => void;
+  private _destinations?: Record<number, (line: string) => void>;
 
   private _formatter?: (...args: any[]) => string;
 
@@ -43,9 +43,23 @@ export default class BasicLogger implements LDLogger {
   constructor(options: BasicLoggerOptions) {
     this._logLevel = LogPriority[options.level ?? 'info'] ?? LogPriority.info;
     this._name = options.name ?? 'LaunchDarkly';
-    // eslint-disable-next-line no-console
-    this._destination = options.destination;
     this._formatter = options.formatter;
+    if (typeof options.destination === 'object') {
+      this._destinations = {
+        [LogPriority.debug]: options.destination.debug,
+        [LogPriority.info]: options.destination.info,
+        [LogPriority.warn]: options.destination.warn,
+        [LogPriority.error]: options.destination.error,
+      };
+    } else if (typeof options.destination === 'function') {
+      const { destination } = options;
+      this._destinations = {
+        [LogPriority.debug]: destination,
+        [LogPriority.info]: destination,
+        [LogPriority.warn]: destination,
+        [LogPriority.error]: destination,
+      };
+    }
   }
 
   private _tryFormat(...args: any[]): string {
@@ -60,9 +74,9 @@ export default class BasicLogger implements LDLogger {
     }
   }
 
-  private _tryWrite(msg: string) {
+  private _tryWrite(destination: (msg: string) => void, msg: string) {
     try {
-      this._destination!(msg);
+      destination(msg);
     } catch {
       // eslint-disable-next-line no-console
       console.error(msg);
@@ -71,10 +85,11 @@ export default class BasicLogger implements LDLogger {
 
   private _log(level: number, args: any[]) {
     if (level >= this._logLevel) {
-      const prefix = `${LevelNames[level]}: [${this._name}]`;
+      const prefix = `${LEVEL_NAMES[level]}: [${this._name}]`;
       try {
-        if (this._destination) {
-          this._tryWrite(`${prefix} ${this._tryFormat(...args)}`);
+        const destination = this._destinations?.[level];
+        if (destination) {
+          this._tryWrite(destination, `${prefix} ${this._tryFormat(...args)}`);
         } else {
           // `console.error` has its own formatter.
           // So we don't need to do anything.
