node, sdk-core: Implement similar fix to the breadcrumbs storage and limit object depth

Author: Konrad Dysput

packages/node/src/breadcrumbs/FileBreadcrumbsStorage.ts

@@ -1,4 +1,5 @@
 import {
+    AttributeType,
     BacktraceAttachment,
     BacktraceAttachmentProvider,
     Breadcrumb,
@@ -107,9 +108,8 @@ export class FileBreadcrumbsStorage implements BreadcrumbsStorage {
             timestamp: TimeHelper.now(),
             type: BreadcrumbType[rawBreadcrumb.type].toLowerCase(),
             level: BreadcrumbLogLevel[rawBreadcrumb.level].toLowerCase(),
-            attributes: rawBreadcrumb.attributes,
+            attributes: this.prepareAttributes(rawBreadcrumb.attributes),
         };
-
         const breadcrumbJson = JSON.stringify(breadcrumb, jsonEscaper());
         const jsonLength = breadcrumbJson.length + 1; // newline
         const sizeLimit = this._limits.maximumTotalBreadcrumbsSize;
@@ -123,6 +123,45 @@ export class FileBreadcrumbsStorage implements BreadcrumbsStorage {
         return id;
     }
 
+    private prepareAttributes(attributes?: Record<string, AttributeType>): Record<string, AttributeType> | undefined {
+        const result: Record<string, AttributeType> = {};
+        if (!attributes) {
+            return undefined;
+        }
+        for (const key in attributes) {
+            const value = attributes[key];
+            switch (typeof value) {
+                case 'number':
+                case 'boolean':
+                case 'string':
+                case 'undefined':
+                    result[key] = value;
+                    break;
+                case 'bigint':
+                    result[key] = (value as bigint).toString();
+                    break;
+                case 'object': {
+                    if (!value) {
+                        result[key] = value;
+                        break;
+                    }
+                    try {
+                        if (value instanceof Date) {
+                            result[key] = value.toISOString();
+                        } else if (value instanceof URL) {
+                            result[key] = value.toString();
+                        }
+                    } catch {
+                        // revoked proxy or broken object — drop it
+                    }
+                    // drop all other objects
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
     private static getFileName(index: number) {
         return `${FILE_PREFIX}-${index}`;
     }

packages/sdk-core/src/common/limitObjectDepth.ts

@@ -2,29 +2,43 @@ type DeepPartial<T extends object> = Partial<{ [K in keyof T]: T[K] extends obje
 
 const REMOVED_PLACEHOLDER = '<removed>';
 
-export type Limited<T extends object> = DeepPartial<T> | typeof REMOVED_PLACEHOLDER;
+export type Limited<T> = (T extends object ? DeepPartial<T> : T) | typeof REMOVED_PLACEHOLDER;
+
+export function limitObjectDepth<T>(val: T, depth: number): Limited<T> {
+    if (typeof val !== 'object' || !val) {
+        return val as Limited<T>;
+    }
 
-export function limitObjectDepth<T extends object>(obj: T, depth: number): Limited<T> {
     if (!(depth < Infinity)) {
-        return obj;
+        return val as Limited<T>;
     }
 
     if (depth < 0) {
         return REMOVED_PLACEHOLDER;
     }
 
-    const limitIfObject = (value: unknown) =>
-        typeof value === 'object' && value ? limitObjectDepth(value, depth - 1) : value;
+    try {
+        if ('toJSON' in val && typeof val.toJSON === 'function') {
+            return limitObjectDepth(val.toJSON(), depth);
+        }
+    } catch (err) {
+        if (err instanceof TypeError) {
+            return REMOVED_PLACEHOLDER;
+        }
+        // broken toJSON — fall through to iterate own properties
+    }
+
+    const limitChild = (value: unknown) => limitObjectDepth(value, depth - 1);
 
-    const result: DeepPartial<T> = {};
-    for (const key in obj) {
-        const value = obj[key];
+    const result: DeepPartial<T & object> = {};
+    for (const key in val) {
+        const value = val[key];
         if (Array.isArray(value)) {
-            result[key] = value.map(limitIfObject) as never;
+            result[key] = value.map(limitChild) as never;
         } else {
-            result[key] = limitIfObject(value) as never;
+            result[key] = limitChild(value) as never;
         }
     }
 
-    return result;
+    return result as Limited<T>;
 }

packages/sdk-core/tests/breadcrumbs/breadcrumbsCreationTests.spec.ts

@@ -1,3 +1,4 @@
+import { AttributeType } from '../../src/index.js';
 import { BreadcrumbsManager } from '../../src/modules/breadcrumbs/BreadcrumbsManager.js';
 import { BreadcrumbLogLevel, BreadcrumbType } from '../../src/modules/breadcrumbs/index.js';
 import { InMemoryBreadcrumbsStorage } from '../../src/modules/breadcrumbs/storage/InMemoryBreadcrumbsStorage.js';
@@ -123,4 +124,22 @@ describe('Breadcrumbs creation tests', () => {
 
         expect(breadcrumb.attributes).toMatchObject(attributes);
     });
+    it('Should handle breadcrumb with not serializable attributes', () => {
+        const message = 'test';
+        const level = BreadcrumbLogLevel.Warning;
+        const attributes = {
+            url: new URL('https://example.com/path?q=1'),
+            date: new Date(),
+            objectCreatePrototype: Object.create(Date.prototype),
+            destroyedUrl: { ...new URL('https://example.com/path?q=1'), date: new Date() },
+        } as unknown as Record<string, AttributeType>;
+        const storage = new InMemoryBreadcrumbsStorage({ maximumBreadcrumbs: 100 });
+        const breadcrumbsManager = new BreadcrumbsManager(undefined, { storage: () => storage });
+        breadcrumbsManager.initialize();
+        breadcrumbsManager.log(message, level, attributes);
+        const [breadcrumb] = JSON.parse(storage.get() as string);
+
+        expect(breadcrumb.attributes['url']).toBeDefined();
+        expect(breadcrumb.attributes['date']).toBeDefined();
+    });
 });