fix(logger): keep repeated references out of the circular-reference fallback

Author: waleedlatif1

packages/logger/src/index.test.ts

@@ -275,6 +275,34 @@ describe('Logger', () => {
       expect(parsed.boom).toBe('[Unreadable]')
     })
 
+    test('should keep repeated references that are not cycles', () => {
+      const shared = { s: 'REAL_DATA', n: 42 }
+      const payload = { p: shared, q: shared, arr: [shared, shared], big: 1n } as unknown as object
+
+      createEnabledLogger().info('hello', payload)
+
+      const parsed = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+      expect(parsed.p).toEqual({ s: 'REAL_DATA', n: 42 })
+      expect(parsed.q).toEqual({ s: 'REAL_DATA', n: 42 })
+      expect(parsed.arr).toEqual([
+        { s: 'REAL_DATA', n: 42 },
+        { s: 'REAL_DATA', n: 42 },
+      ])
+      expect(parsed.big).toBe('1')
+    })
+
+    test('should still mark a genuine cycle as circular', () => {
+      const cyclic: Record<string, unknown> = { name: 'root' }
+      cyclic.self = cyclic
+      const payload = { cyclic, big: 1n } as unknown as object
+
+      createEnabledLogger().info('hello', payload)
+
+      const parsed = JSON.parse(consoleLogSpy.mock.calls[0][0] as string)
+      expect(parsed.cyclic.name).toBe('root')
+      expect(parsed.cyclic.self).toBe('[Circular]')
+    })
+
     test('should not throw when retained metadata has a throwing toJSON', () => {
       const hostile = {
         evil: {

packages/logger/src/index.ts

@@ -157,13 +157,20 @@ const mergeArgs = (entry: Record<string, unknown>, args: unknown[]): Record<stri
 
 /** JSON replacer that tolerates cyclic references and BigInt values. */
 const tolerantReplacer = () => {
-  const seen = new WeakSet<object>()
-  return (_key: string, value: unknown): unknown => {
+  const ancestors: object[] = []
+  return function (this: unknown, _key: string, value: unknown): unknown {
     if (typeof value === 'bigint') return value.toString()
-    if (value !== null && typeof value === 'object') {
-      if (seen.has(value)) return '[Circular]'
-      seen.add(value)
-    }
+    if (value === null || typeof value !== 'object') return value
+    /**
+     * Track the ancestor path, not every object ever visited. `this` is the
+     * object holding the current key, so unwinding to it drops the siblings we
+     * have finished descending. A set of everything seen would label the second
+     * appearance of a merely repeated reference `[Circular]` and discard real
+     * data, since a payload that references one object twice has no cycle.
+     */
+    while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) ancestors.pop()
+    if (ancestors.includes(value)) return '[Circular]'
+    ancestors.push(value)
     return value
   }
 }