fix(logger): no longer detects duplicate object as circular

spec/logger.spec.ts

@@ -118,6 +118,50 @@ describe("logger", () => {
           });
         });
 
+        it("should not detect duplicate object as circular", () => {
+          const obj: any = { a: "foo" };
+          const entry: logger.LogEntry = {
+            severity: "ERROR",
+            message: "testing circular",
+            a: obj,
+            b: obj,
+          };
+          logger.write(entry);
+          expectStderr({
+            severity: "ERROR",
+            message: "testing circular",
+            a: { a: "foo" },
+            b: { a: "foo" },
+          });
+        });
+
+        it("should not detect duplicate object in array as circular", () => {
+          const obj: any = { a: "foo" };
+          const arr: any = [
+            { a: obj, b: obj },
+            { a: obj, b: obj },
+          ];
+          const entry: logger.LogEntry = {
+            severity: "ERROR",
+            message: "testing circular",
+            a: arr,
+            b: arr,
+          };
+          logger.write(entry);
+          expectStderr({
+            severity: "ERROR",
+            message: "testing circular",
+            a: [
+              { a: { a: "foo" }, b: { a: "foo" } },
+              { a: { a: "foo" }, b: { a: "foo" } },
+            ],
+            b: [
+              { a: { a: "foo" }, b: { a: "foo" } },
+              { a: { a: "foo" }, b: { a: "foo" } },
+            ],
+          });
+        });
+
         it("should not break on objects that override toJSON", () => {
           const obj: any = { a: new Date("August 26, 1994 12:24:00Z") };
 

src/logger/index.ts

@@ -56,28 +56,32 @@ function removeCircular(obj: any, refs: any[] = []): any {
   if (typeof obj !== "object" || !obj) {
     return obj;
   }
-  // If the object defines its own toJSON, prefer that.
-  if (obj.toJSON) {
+  // If the object defines its own toJSON method, use it.
+  if (obj.toJSON && typeof obj.toJSON === "function") {
     return obj.toJSON();
   }
+  // Only check for circularity among ancestors in the recursion stack.
   if (refs.includes(obj)) {
     return "[Circular]";
-  } else {
-    refs.push(obj);
   }
+  // Add the current object to the recursion stack.
+  refs.push(obj);
+
+  // If the object is an array, run circular check on each element.
   let returnObj: any;
   if (Array.isArray(obj)) {
-    returnObj = new Array(obj.length);
-  } else {
-    returnObj = {};
+    returnObj = obj.map((item) => removeCircular(item, refs));
   }
-  for (const k in obj) {
-    if (refs.includes(obj[k])) {
-      returnObj[k] = "[Circular]";
-    } else {
-      returnObj[k] = removeCircular(obj[k], refs);
+  // If the object is a Map, run circular check on each key and value.
+  else {
+    returnObj = {};
+    for (const key of Object.keys(obj)) {
+      returnObj[key] = removeCircular(obj[key], refs);
     }
   }
+
+  // Remove the current object from the stack once its properties are processed.
+  refs.pop();
   return returnObj;
 }