fix(logger): keep a throwing toJSON from escaping the final fallback

Author: waleedlatif1

packages/logger/src/index.test.ts

@@ -275,6 +275,25 @@ describe('Logger', () => {
       expect(parsed.boom).toBe('[Unreadable]')
     })
 
+    test('should not throw when retained metadata has a throwing toJSON', () => {
+      const hostile = {
+        evil: {
+          toJSON() {
+            throw new Error('toJSON exploded')
+          },
+        },
+      } as unknown as Parameters<Logger['withMetadata']>[0]
+
+      const child = createEnabledLogger().withMetadata(hostile)
+
+      expect(() => child.info('hello')).not.toThrow()
+      const parsed = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+      expect(parsed.message).toBe('hello')
+      expect(parsed.module).toBe('Test')
+      expect(parsed.serializationError).toBe(true)
+      expect(parsed.evil).toBeUndefined()
+    })
+
     test('should not throw when withMetadata receives a hostile proxy', () => {
       const hostile = new Proxy(
         {},

packages/logger/src/index.ts

@@ -185,7 +185,27 @@ const serializeEntry = (base: Record<string, unknown>, args: unknown[]): string
     return JSON.stringify(mergeArgs({ ...base }, args), tolerantReplacer())
   } catch {}
 
-  return JSON.stringify({ ...base, serializationError: true }, tolerantReplacer())
+  return minimalEntry(base)
+}
+
+/**
+ * Last-resort entry built only from fields this module controls.
+ *
+ * A replacer cannot rescue a throwing `toJSON`, because `JSON.stringify` invokes
+ * it before the replacer ever sees the value. So the final fallback drops every
+ * caller-supplied value instead of re-serializing it, and passes strings through
+ * only when they are already strings — coercing would re-enter hostile
+ * `toString`. What remains cannot throw.
+ */
+const minimalEntry = (base: Record<string, unknown>): string => {
+  const asString = (value: unknown) => (typeof value === 'string' ? value : '[Unserializable]')
+  return JSON.stringify({
+    timestamp: asString(base.timestamp),
+    level: asString(base.level),
+    module: asString(base.module),
+    message: asString(base.message),
+    serializationError: true,
+  })
 }
 
 /**