@sockethub/logger 1.0.0-alpha.11 → 1.0.0-alpha.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sockethub/logger",
   "description": "Winston-based logger for Sockethub packages",
-  "version": "1.0.0-alpha.11",
+  "version": "1.0.0-alpha.12",
   "type": "module",
   "private": false,
   "author": "Nick Jennings <nick@silverbucket.net>",
@@ -47,5 +47,5 @@
   "devDependencies": {
     "@types/bun": "latest"
   },
-  "gitHead": "c243fa9e76c688ce5ffcf524400b1dd27dcce615"
+  "gitHead": "f039dab3c3f67cbbf204476fc397532e973f82a8"
 }

package/src/index.test.ts

@@ -176,6 +176,85 @@ describe("Logger Package", () => {
             const log2 = createLogger("test:2");
             expect(log2.transports.length).toBe(2);
         });
+
+        it("serializes circular metadata with [Circular] marker in log output", () => {
+            const previousNodeEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = "production";
+
+            try {
+                const log = createLogger("test:namespace");
+                const circular: { self?: unknown } = {};
+                circular.self = circular;
+
+                const consoleTransport = log.transports[0] as {
+                    format: {
+                        transform: (
+                            info: Record<string, unknown>,
+                            opts?: unknown,
+                        ) => Record<PropertyKey, unknown>;
+                        options?: unknown;
+                    };
+                };
+
+                const transformed = consoleTransport.format.transform(
+                    {
+                        level: "info",
+                        [Symbol.for("level")]: "info",
+                        message: "circular metadata test",
+                        namespace: "test:namespace",
+                        circular,
+                    },
+                    consoleTransport.format.options,
+                );
+                const output = String(
+                    transformed[Symbol.for("message")] ?? "",
+                ).replace(/\u001b\[[0-9;]*m/g, "");
+
+                expect(output).toContain("circular metadata test");
+                expect(output).toContain("\"[Circular]\"");
+            } finally {
+                process.env.NODE_ENV = previousNodeEnv;
+            }
+        });
+
+        it("serializes Error metadata with name/message/stack in log output", () => {
+            const previousNodeEnv = process.env.NODE_ENV;
+            process.env.NODE_ENV = "production";
+
+            try {
+                const log = createLogger("test:namespace");
+                const consoleTransport = log.transports[0] as {
+                    format: {
+                        transform: (
+                            info: Record<string, unknown>,
+                            opts?: unknown,
+                        ) => Record<PropertyKey, unknown>;
+                        options?: unknown;
+                    };
+                };
+
+                const transformed = consoleTransport.format.transform(
+                    {
+                        level: "error",
+                        [Symbol.for("level")]: "error",
+                        message: "error metadata test",
+                        namespace: "test:namespace",
+                        err: new Error("boom"),
+                    },
+                    consoleTransport.format.options,
+                );
+                const output = String(
+                    transformed[Symbol.for("message")] ?? "",
+                ).replace(/\u001b\[[0-9;]*m/g, "");
+
+                expect(output).toContain("error metadata test");
+                expect(output).toContain("\"name\":\"Error\"");
+                expect(output).toContain("\"message\":\"boom\"");
+                expect(output).toContain("\"stack\"");
+            } finally {
+                process.env.NODE_ENV = previousNodeEnv;
+            }
+        });
     });
 
     describe("logger context", () => {

package/src/index.ts

@@ -16,6 +16,43 @@ let hasLoggedInit = false;
 let loggerContext = "";
 let loggerNamespaceStore = new WeakMap<Logger, string>();
 
+// Keep log formatting resilient when metadata contains errors, bigints, or cycles.
+function safeStringify(value: unknown): string {
+    try {
+        const parents: object[] = [];
+        return JSON.stringify(value, function (_key, innerValue) {
+            if (innerValue instanceof Error) {
+                return {
+                    name: innerValue.name,
+                    message: innerValue.message,
+                    stack: innerValue.stack,
+                };
+            }
+            if (typeof innerValue === "bigint") {
+                return innerValue.toString();
+            }
+            if (typeof innerValue === "object" && innerValue !== null) {
+                // Only treat values on the current traversal path as circular.
+                // Shared references in sibling branches should serialize normally.
+                const parent = this as unknown;
+                while (
+                    parents.length > 0 &&
+                    parents[parents.length - 1] !== parent
+                ) {
+                    parents.pop();
+                }
+                if (parents.includes(innerValue)) {
+                    return "[Circular]";
+                }
+                parents.push(innerValue);
+            }
+            return innerValue;
+        });
+    } catch {
+        return '"[Unserializable]"';
+    }
+}
+
 /**
  * Initialize the logger system with global configuration.
  *
@@ -174,7 +211,7 @@ export function createLogger(
                       const ns = namespace ? `${namespace} ` : "";
                       const metaStr =
                           Object.keys(meta).length > 0
-                              ? ` ${JSON.stringify(meta)}`
+                              ? ` ${safeStringify(meta)}`
                               : "";
                       return `${level}: ${ns}${message}${metaStr}`;
                   },
@@ -188,7 +225,7 @@ export function createLogger(
                       const ns = namespace ? `${namespace} ` : "";
                       const metaStr =
                           Object.keys(meta).length > 0
-                              ? ` ${JSON.stringify(meta)}`
+                              ? ` ${safeStringify(meta)}`
                               : "";
                       return `${timestamp} ${level}: ${ns}${message}${metaStr}`;
                   },