fix(browser): Add a synthetic stack trace to DOMException with empty stack traces if attachStacktrace is true

Author: abcang

packages/browser/src/eventbuilder.ts

@@ -288,7 +288,7 @@ export function eventFromUnknownInput(
   if (isDOMError(exception) || isDOMException(exception as DOMException)) {
     const domException = exception as DOMException;
 
-    if ('stack' in (exception as Error)) {
+    if ((exception as Error).stack) {
       event = eventFromError(stackParser, exception as Error);
     } else {
       const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');

packages/browser/test/eventbuilder.test.ts

@@ -168,6 +168,81 @@ describe('eventFromUnknownInput', () => {
       },
     });
   });
+
+  it('add a synthetic stack trace to DOMException with empty stack traces if attachStacktrace is true', async () => {
+    const exception = new DOMException('The string did not match the expected pattern.', 'SyntaxError');
+    exception.stack = '';
+
+    const syntheticException = new Error('Test message');
+    const event = await eventFromUnknownInput(defaultStackParser, exception, syntheticException, true);
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        stacktrace: {
+          frames: expect.arrayContaining([expect.any(Object), expect.any(Object)]),
+        },
+        type: 'Error',
+        value: 'SyntaxError: The string did not match the expected pattern.',
+      }),
+    );
+  });
+
+  it('add a synthetic stack trace to DOMException without a stack traces property if attachStacktrace is true', async () => {
+    const exception = new DOMException('The string did not match the expected pattern.', 'SyntaxError');
+    delete exception.stack;
+
+    const syntheticException = new Error('Test message');
+    const event = await eventFromUnknownInput(defaultStackParser, exception, syntheticException, true);
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        mechanism: { handled: true, synthetic: true, type: 'generic' },
+        stacktrace: {
+          frames: expect.arrayContaining([expect.any(Object), expect.any(Object)]),
+        },
+        type: 'Error',
+        value: 'SyntaxError: The string did not match the expected pattern.',
+      }),
+    );
+  });
+
+  it("doesn't add a synthetic stack trace to DOMException with empty stack traces if attachStacktrace is false", async () => {
+    const exception = new DOMException('The string did not match the expected pattern.', 'SyntaxError');
+    exception.stack = '';
+
+    const syntheticException = new Error('Test message');
+    const event = await eventFromUnknownInput(defaultStackParser, exception, syntheticException, false);
+    expect(event.exception?.values?.[0]).toEqual(
+      {
+        type: 'Error',
+        value: 'SyntaxError: The string did not match the expected pattern.',
+      },
+    );
+  });
+
+  it("doesn't add a synthetic stack trace to DOMException with stack traces if attachStacktrace is true", async () => {
+    const exception = new DOMException('The string did not match the expected pattern.', 'SyntaxError');
+    exception.stack = 'SyntaxError\n    at <anonymous>:1:2';
+
+    const syntheticException = new Error('Test message');
+    const event = await eventFromUnknownInput(defaultStackParser, exception, syntheticException, true);
+    expect(event.exception?.values?.[0]).toEqual(
+      expect.objectContaining({
+        stacktrace: {
+          frames: [
+            {
+              colno: 2,
+              filename: "<anonymous>",
+              function: "?",
+              in_app: true,
+              lineno: 1,
+            },
+          ],
+        },
+        type: 'SyntaxError',
+        value: 'The string did not match the expected pattern.',
+      }),
+    );
+  });
 });
 
 describe('extractMessage', () => {