fix(logger): fix util.format polyfill to accept object as given param…

…eter

packages/logger/src/browser/exports.ts

@@ -1,9 +1,11 @@
-import {Logger, PatternLayout} from "../common";
+import {Logger, PatternLayout, StringUtils} from "../common";
 import {LayoutReplacer} from "./layouts/LayoutReplacer";
+import {format} from "./utils/format";
 
 export * from "../common";
 export const $log: Logger = new Logger("default");
 
 $log.appenders.set("console", {type: "console", levels: ["info", "debug", "trace", "fatal", "error", "warn"]});
 
 PatternLayout.LayoutReplacer = LayoutReplacer;
+StringUtils.format = format;

packages/logger/src/browser/layouts/LayoutReplacer.ts

@@ -5,7 +5,7 @@ import {LOG_COLORS} from "../../common/layouts/constants/logColors";
 import {colorizeEnd, colorizeStart} from "../../common/layouts/utils/colorizeUtils";
 import {IReplacers} from "../../common/layouts/interfaces/Replacers";
 import {TokensHandlers} from "../../common/layouts/interfaces/BasicLayoutConfiguration";
-import {format} from "../../common/layouts/utils/StringUtils";
+import {format} from "../utils/format";
 
 export class LayoutReplacer {
   static EOL = "\n";

packages/logger/src/browser/utils/format.spec.ts

@@ -0,0 +1,58 @@
+import {format} from "./format";
+
+describe("format()", () => {
+  it("should use format string", () => {
+    const res = format("foo");
+    expect(res).toEqual("foo");
+  });
+
+  it("should format string (%s)", () => {
+    const res = format("%s", "foo");
+    expect(res).toEqual("foo");
+  });
+
+  it("should format multiple strings (%s:%s)", () => {
+    const res = format("%s:%s", "foo", "bar");
+    expect(res).toEqual("foo:bar");
+  });
+
+  it("should format digit as NaN (%d)", () => {
+    const res = format("%d", "foo");
+    expect(res).toEqual("NaN");
+  });
+
+  it("should format digit (%d)", () => {
+    const res = format("%d", "16");
+    expect(res).toEqual("16");
+  });
+
+  it("should format json string (%j)", () => {
+    const res = format("%j", "foo");
+    expect(res).toEqual('"foo"');
+  });
+
+  it("should format json array (%j)", () => {
+    const res = format("%j", [1, 2, 3]);
+    expect(res).toEqual("[1,2,3]");
+  });
+
+  it("should format object string (%o)", () => {
+    const res = format("%o", "foo");
+    expect(res).toEqual("foo");
+  });
+
+  it("should format error (%o)", () => {
+    const res = format("%o", new Error("mock error"));
+    expect(res).toEqual("Error: mock error");
+  });
+
+  it("should format object array (%o)", () => {
+    const res = format("%o", [1, 2, 3]);
+    expect(res).toEqual("[1,2,3]");
+  });
+
+  it("should format escaped string (%s)", () => {
+    const res = format("%%s", "foo");
+    expect(res).toEqual("%s foo");
+  });
+});

packages/logger/src/browser/utils/format.ts

@@ -0,0 +1,48 @@
+export function format(fmt: string | object, ...args: unknown[]) {
+  const re = /(%?)(%([ojds]))/g;
+
+  if (typeof fmt === "object") {
+    fmt = JSON.stringify(fmt, null, 2);
+  }
+
+  if (args.length) {
+    const replacer = (match: any, escaped: any, ptn: any, flag: any) => {
+      let arg = args.shift();
+      switch (flag) {
+        case "o":
+          if (Array.isArray(arg)) {
+            arg = JSON.stringify(arg);
+            break;
+          }
+        case "s":
+          arg = "" + arg;
+          break;
+        case "d":
+          arg = Number(arg);
+          break;
+        case "j":
+          arg = JSON.stringify(arg);
+          break;
+      }
+
+      if (!escaped) {
+        return arg;
+      }
+
+      args.unshift(arg);
+      return match;
+    };
+
+    fmt = String(fmt).replace(re, replacer);
+  }
+
+  // arguments remain after formatting
+  if (args.length) {
+    fmt += " " + args.join(" ");
+  }
+
+  // update escaped %% values
+  fmt = String(fmt).replace(/%{2,2}/g, "%");
+
+  return "" + fmt;
+}

packages/logger/src/common/appenders/components/ConsoleAppender.spec.ts

@@ -2,6 +2,10 @@ import {ConsoleAppender} from "./ConsoleAppender";
 import {LogEvent} from "../../core/LogEvent";
 import {levels} from "../../core/LogLevel";
 import "../../layouts/components/ColoredLayout";
+import {StringUtils} from "../../layouts/utils/StringUtils";
+import {format} from "node:util";
+
+StringUtils.format = format;
 
 describe("ConsoleAppender", () => {
   it("should log something", () => {

packages/logger/src/common/layouts/components/BasicLayout.spec.ts

@@ -1,6 +1,10 @@
 import {LogEvent} from "../../core/LogEvent";
 import {levels} from "../../core/LogLevel";
 import {BasicLayout} from "./BasicLayout";
+import {StringUtils} from "../utils/StringUtils";
+import {format} from "node:util";
+
+StringUtils.format = format;
 
 describe("BasicLayout", () => {
   it("should return a formated string", () => {

packages/logger/src/common/layouts/components/BasicLayout.ts

@@ -2,7 +2,7 @@ import {timestampLevelAndCategory} from "../utils/timestampLevelAndCategory";
 import {BaseLayout} from "../class/BaseLayout";
 import {LogEvent} from "../../core/LogEvent";
 import {Layout} from "../decorators/layout";
-import {format} from "../utils/StringUtils";
+import {StringUtils} from "../utils/StringUtils";
 
 @Layout({name: "basic"})
 export class BasicLayout extends BaseLayout {
@@ -16,6 +16,9 @@ export class BasicLayout extends BaseLayout {
    * @author Stephan Strittmatter
    */
   transform(loggingEvent: LogEvent, timezoneOffset?: number): string {
-    return timestampLevelAndCategory(loggingEvent, undefined, timezoneOffset) + (format as any)(...[].concat(loggingEvent.data as any));
+    return (
+      timestampLevelAndCategory(loggingEvent, undefined, timezoneOffset) +
+      (StringUtils.format as any)(...[].concat(loggingEvent.data as any))
+    );
   }
 }

packages/logger/src/common/layouts/components/ColoredLayout.spec.ts

@@ -1,6 +1,10 @@
 import {LogEvent} from "../../core/LogEvent";
 import {levels} from "../../core/LogLevel";
 import {ColoredLayout} from "./ColoredLayout";
+import {StringUtils} from "../utils/StringUtils";
+import {format} from "node:util";
+
+StringUtils.format = format;
 
 describe("ColoredLayout", () => {
   it("should return a formatted string", () => {
@@ -18,4 +22,37 @@ describe("ColoredLayout", () => {
 
     expect(result).toEqual(expect.stringContaining("[36m[2017-06-18T22:29:38.234] [DEBUG] [category] - data"));
   });
+
+  it("should return a formatted string from object", () => {
+    const layout = new ColoredLayout({
+      type: "colored"
+    });
+
+    const context = new Map();
+    context.set("user", "romain");
+
+    const logEvent = new LogEvent(
+      "category",
+      levels().DEBUG,
+      [
+        {
+          id: "id",
+          event: "event",
+          headers: {
+            accept: "application/json"
+          }
+        }
+      ],
+      context as any
+    );
+    (logEvent as any)._startTime = new Date("2017-06-18 22:29:38.234");
+
+    const result = layout.transform(logEvent);
+
+    expect(result).toEqual(
+      expect.stringContaining(
+        "[2017-06-18T22:29:38.234] [DEBUG] [category] - { id: 'id', event: 'event', headers: { accept: 'application/json' } }"
+      )
+    );
+  });
 });

packages/logger/src/common/layouts/components/ColoredLayout.ts

@@ -3,7 +3,7 @@ import {timestampLevelAndCategory} from "../utils/timestampLevelAndCategory";
 import {LOG_COLORS} from "../constants/logColors";
 import {Layout} from "../decorators/layout";
 import {BaseLayout} from "../class/BaseLayout";
-import {format} from "../utils/StringUtils";
+import {StringUtils} from "../utils/StringUtils";
 
 @Layout({name: "colored"})
 export class ColoredLayout extends BaseLayout {
@@ -14,6 +14,8 @@ export class ColoredLayout extends BaseLayout {
   transform(loggingEvent: LogEvent, timezoneOffset?: number): string {
     const index: any = loggingEvent.level.toString();
     const color = LOG_COLORS[index as keyof typeof LOG_COLORS];
-    return timestampLevelAndCategory(loggingEvent, color, timezoneOffset) + (format as any)(...[].concat(loggingEvent.data as any));
+    return (
+      timestampLevelAndCategory(loggingEvent, color, timezoneOffset) + (StringUtils.format as any)(...[].concat(loggingEvent.data as any))
+    );
   }
 }

packages/logger/src/common/layouts/components/JsonLayout.spec.ts

@@ -2,6 +2,10 @@ import {LogEvent} from "../../core/LogEvent";
 import {levels} from "../../core/LogLevel";
 import {JsonLayout} from "./JsonLayout";
 import {LogContext} from "../../core/LogContext";
+import {StringUtils} from "../utils/StringUtils";
+import {format} from "node:util";
+
+StringUtils.format = format;
 
 describe("JsonLayout", () => {
   describe("when separator is given", () => {

packages/logger/src/common/layouts/components/MessagePassThroughLayout.spec.ts

@@ -1,6 +1,10 @@
 import {LogEvent} from "../../core/LogEvent";
 import {levels} from "../../core/LogLevel";
 import {MessagePassThroughLayout} from "./MessagePassThroughLayout";
+import {StringUtils} from "../utils/StringUtils";
+import {format} from "node:util";
+
+StringUtils.format = format;
 
 describe("MessagePassThroughLayout", () => {
   it("should return a formatted string", () => {

packages/logger/src/common/layouts/components/MessagePassThroughLayout.ts

@@ -1,12 +1,12 @@
 import {BaseLayout} from "../class/BaseLayout";
 import {LogEvent} from "../../core/LogEvent";
 import {Layout} from "../decorators/layout";
-import {format} from "../utils/StringUtils";
+import {StringUtils} from "../utils/StringUtils";
 
 @Layout({name: "messagePassThrough"})
 export class MessagePassThroughLayout extends BaseLayout {
   transform(loggingEvent: LogEvent, timezoneOffset?: number): string {
     // @ts-ignore
-    return format(...[].concat(loggingEvent.data as any));
+    return StringUtils.format(...[].concat(loggingEvent.data as any));
   }
 }

packages/logger/src/common/layouts/utils/StringUtils.ts

@@ -35,47 +35,8 @@ export function truncateAndPad(toTruncAndPad: string, truncation: string, paddin
   return replacement;
 }
 
-export function format(fmt: string, ...args: unknown[]) {
-  const re = /(%?)(%([ojds]))/g;
-
-  if (args.length) {
-    const replacer = (match: any, escaped: any, ptn: any, flag: any) => {
-      let arg = args.shift();
-      switch (flag) {
-        case "o":
-          if (Array.isArray(arg)) {
-            arg = JSON.stringify(arg);
-            break;
-          }
-        case "s":
-          arg = "" + arg;
-          break;
-        case "d":
-          arg = Number(arg);
-          break;
-        case "j":
-          arg = JSON.stringify(arg);
-          break;
-      }
-
-      if (!escaped) {
-        return arg;
-      }
-
-      args.unshift(arg);
-      return match;
-    };
-
-    fmt = String(fmt).replace(re, replacer);
+export const StringUtils = {
+  format(fmt: string | object, ...args: any[]): string {
+    return "";
   }
-
-  // arguments remain after formatting
-  if (args.length) {
-    fmt += " " + args.join(" ");
-  }
-
-  // update escaped %% values
-  fmt = String(fmt).replace(/%{2,2}/g, "%");
-
-  return "" + fmt;
-}
+};