feat(logger): extend logger to accept many arguments

Before this commit a logger method like info could only accept one argument
of type string. A logger method can now accept multiple aguments which
can have any type.

Author: christoph-fricke

README.md

@@ -215,12 +215,12 @@ Interface that every logger implements.
 
 ```typescript
 interface ILogger {
-  verbose(msg: string): void;
-  debug(msg: string): void;
-  info(msg: string): void;
-  warning(msg: string): void;
-  error(err: string | Error): void;
-  critical(err: string | Error): void;
+  verbose(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warning(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  critical(...args: unknown[]): void;
 
   withContext(context: string): ILogger;
   addHandler(
@@ -260,7 +260,9 @@ interface ILogRecord {
   readonly levelName: keyof typeof LogLevel;
   /** Context used for this record. */
   readonly context: string;
-  /** Stored message. */
+  /** Arguments that were passed to the logger. */
+  readonly args: unknown[];
+  /** Arguments formatted as a string. */
   readonly message: string;
   /** Timestamp at which the log record was created. */
   readonly date: Date;

src/log-record.test.ts

@@ -3,7 +3,7 @@ import { LogLevel } from "./log-level";
 
 describe("LogRecord", () => {
   it("should construct a valid LogRecord", () => {
-    const record = new LogRecord("test message", {
+    const record = new LogRecord(["test message"], {
       level: LogLevel.INFO,
       context: "Test",
       metadata: { key1: 123 },
@@ -13,19 +13,59 @@ describe("LogRecord", () => {
     expect(record.levelName).toBe("INFO");
     expect(record.context).toBe("Test");
     expect(record.message).toBe("test message");
+    expect(record.args).toStrictEqual(["test message"]);
   });
 
   it("should include the current date", () => {
     const date = new Date("2020-04-01T12:15:32.000Z");
     jest.useFakeTimers("modern");
     jest.setSystemTime(date);
 
-    const record = new LogRecord("test message", {
+    const record = new LogRecord(["test message"], {
       level: LogLevel.INFO,
       context: "Test",
       metadata: { key1: 123 },
     });
 
     expect(record.date).toStrictEqual(date);
   });
+
+  const cases: [args: unknown[], parsed: string][] = [
+    [[], ""],
+    [["log message"], "log message"],
+    [["message1", "message2"], "message1 message2"],
+    [[true, false], "true false"],
+    [[1, 2], "1 2"],
+    [[(a: number, b: number) => a + b], "[Function (anonymous)]"],
+    [[[]], "[]"],
+    [[{}], "{}"],
+    [[{ key: 1, key2: 2 }], '{"key":1,"key2":2}'],
+    [[null], "null"],
+    [[undefined, 1], "undefined 1"],
+    [
+      [
+        function sum(a: number, b: number) {
+          return a + b;
+        },
+      ],
+      "[Function sum]",
+    ],
+    [
+      [
+        [1, 2, 3],
+        [4, 5, 6],
+      ],
+      "[1,2,3] [4,5,6]",
+    ],
+  ];
+
+  it.each(cases)('Given arguments "%s" are parsed to "%s"', (args, parsed) => {
+    const record = new LogRecord(args, {
+      context: "default",
+      level: LogLevel.INFO,
+      metadata: {},
+    });
+
+    expect(record.message).toBe(parsed);
+  });
 });

src/log-record.ts

@@ -10,7 +10,9 @@ export interface ILogRecord {
   readonly levelName: keyof typeof LogLevel;
   /** Context used for this record. */
   readonly context: string;
-  /** Stored message. */
+  /** Arguments that were passed to the logger. */
+  readonly args: unknown[];
+  /** Arguments formatted as a string. */
   readonly message: string;
   /** Timestamp at which the log record was created. */
   readonly date: Date;
@@ -32,16 +34,60 @@ export class LogRecord implements ILogRecord {
   readonly level: LogLevel;
   readonly levelName: keyof typeof LogLevel;
   readonly context: string;
+  readonly args: unknown[];
   readonly message: string;
   readonly date: Date;
   readonly metadata: Record<string, unknown>;
 
-  constructor(message: string, config: LogRecordConfig) {
+  constructor(args: unknown[], config: LogRecordConfig) {
     this.level = config.level;
     this.levelName = getLogLevelName(config.level);
     this.context = config.context;
-    this.message = message;
+    this.args = args;
+    this.message = argsToString(args);
     this.date = new Date();
     this.metadata = config.metadata;
   }
 }
+
+/**@hidden */
+function argsToString(args: unknown[]): string {
+  return args.reduce(
+    (prev: string, curr) =>
+      prev === "" ? asString(curr) : `${prev} ${asString(curr)}`,
+    ""
+  );
+}
+
+/**@hidden */
+function asString(data: unknown): string {
+  if (typeof data === "string") {
+    return data;
+  }
+
+  if (
+    data === null ||
+    typeof data === "number" ||
+    typeof data === "bigint" ||
+    typeof data === "boolean" ||
+    typeof data === "undefined" ||
+    typeof data === "symbol"
+  ) {
+    return String(data);
+  }
+
+  if (data instanceof Error) {
+    return data.stack ?? data.message;
+  }
+
+  if (typeof data === "object") {
+    return JSON.stringify(data);
+  }
+
+  if (typeof data === "function") {
+    const funcName = data.name !== "" ? data.name : "(anonymous)";
+    return `[Function ${funcName}]`;
+  }
+
+  return "undefined";
+}

src/logger.test.ts

@@ -147,35 +147,25 @@ describe("Logger", () => {
   });
 
   type Method = "verbose" | "debug" | "info" | "warning" | "error" | "critical";
-  const tests: [Method, string | Error, LogLevel][] = [
+  const tests: [level: Method, msg: string, level: LogLevel][] = [
     ["verbose", "test message", LogLevel.VERBOSE],
     ["debug", "test message", LogLevel.DEBUG],
     ["info", "test message", LogLevel.INFO],
     ["warning", "test message", LogLevel.WARNING],
     ["error", "test message", LogLevel.ERROR],
-    ["error", new Error("test Error"), LogLevel.ERROR],
     ["critical", "test message", LogLevel.CRITICAL],
-    ["critical", new Error("test Error"), LogLevel.CRITICAL],
   ];
 
   describe.each(tests)("%s", (method, msg, level) => {
-    it(`creates a log record with the given message, metadata and level ${level}`, () => {
+    it(`creates a log record with the given args, metadata and level ${level}`, () => {
       const handler = new TestHandler();
       const logger = new Logger()
         .addMetadata({ key1: "Test" })
         .addHandler(handler);
 
-      if (typeof msg === "string") {
-        logger[method](msg as string);
-
-        expect(handler.records[0].message).toBe(msg);
-      } else {
-        // We have an error object as msg which is only for error or critical.
-        logger[method as "error" | "critical"](msg);
-
-        expect(handler.records[0].message).toBe(msg.message);
-      }
+      logger[method](msg);
 
+      expect(handler.records[0].args).toStrictEqual([msg]);
       expect(handler.records[0].level).toBe(level);
       expect(handler.records[0].metadata).toStrictEqual({ key1: "Test" });
     });
@@ -185,8 +175,7 @@ describe("Logger", () => {
       const handler2 = new TestHandler();
       const logger = new Logger().addHandler(handler1).addHandler(handler2);
 
-      // We don't care if msg is an error in error and critical case.
-      logger[method](msg as string);
+      logger[method](msg);
 
       expect(handler1.records).toHaveLength(1);
       expect(handler2.records).toHaveLength(1);
@@ -197,8 +186,7 @@ describe("Logger", () => {
       const handler2 = new TestHandler();
       const logger = new Logger().addHandler(handler1).addHandler(handler2);
 
-      // We don't care if msg is an error in error and critical case.
-      logger[method](msg as string);
+      logger[method](msg);
 
       expect(handler1.records[0]).toBe(handler2.records[0]);
     });

src/logger.ts

@@ -4,22 +4,22 @@ import { LogRecord } from "./log-record";
 
 export interface ILogger {
   /** Sends a log record with the level VERBOSE to all handlers.*/
-  verbose(msg: string): void;
+  verbose(...args: unknown[]): void;
 
   /** Sends a log record with the level DEBUG to all handlers.*/
-  debug(msg: string): void;
+  debug(...args: unknown[]): void;
 
   /** Sends a log record with the level INFO to all handlers.*/
-  info(msg: string): void;
+  info(...args: unknown[]): void;
 
   /** Sends a log record with the level WARNING to all handlers.*/
-  warning(msg: string): void;
+  warning(...args: unknown[]): void;
 
   /** Sends a log record with the level ERROR to all handlers.*/
-  error(err: string | Error): void;
+  error(...args: unknown[]): void;
 
   /** Sends a log record with the level CRITICAL to all handlers.*/
-  critical(err: string | Error): void;
+  critical(...args: unknown[]): void;
 
   /**
    * Creates a new `logger` scoped to a given `context`. All current handlers and metadata
@@ -111,8 +111,8 @@ export class Logger implements ILogger {
     return this;
   }
 
-  private notifyHandlers(level: LogLevel, message: string) {
-    const record = new LogRecord(message, {
+  private notifyHandlers(level: LogLevel, args: unknown[]) {
+    const record = new LogRecord(args, {
       level,
       context: this._context,
       metadata: this._metadata,
@@ -122,31 +122,27 @@ export class Logger implements ILogger {
     }
   }
 
-  verbose(msg: string): void {
-    this.notifyHandlers(LogLevel.VERBOSE, msg);
+  verbose(...args: unknown[]): void {
+    this.notifyHandlers(LogLevel.VERBOSE, args);
   }
 
-  debug(msg: string): void {
-    this.notifyHandlers(LogLevel.DEBUG, msg);
+  debug(...args: unknown[]): void {
+    this.notifyHandlers(LogLevel.DEBUG, args);
   }
 
-  info(msg: string): void {
-    this.notifyHandlers(LogLevel.INFO, msg);
+  info(...args: unknown[]): void {
+    this.notifyHandlers(LogLevel.INFO, args);
   }
 
-  warning(msg: string): void {
-    this.notifyHandlers(LogLevel.WARNING, msg);
+  warning(...args: unknown[]): void {
+    this.notifyHandlers(LogLevel.WARNING, args);
   }
 
-  error(err: string | Error): void {
-    const message = typeof err === "string" ? err : err.message;
-
-    this.notifyHandlers(LogLevel.ERROR, message);
+  error(...args: unknown[]): void {
+    this.notifyHandlers(LogLevel.ERROR, args);
   }
 
-  critical(err: string | Error): void {
-    const message = typeof err === "string" ? err : err.message;
-
-    this.notifyHandlers(LogLevel.CRITICAL, message);
+  critical(...args: unknown[]): void {
+    this.notifyHandlers(LogLevel.CRITICAL, args);
   }
 }