test(core): Keeping mechanism on captured error, not on its chained cause (#23244)

Author: s1gr1d

dev-packages/browser-integration-tests/suites/public-api/captureException/aggregateError-custom/subject.js

@@ -13,4 +13,16 @@ const aggregateError = new CustomAggregateError(
   },
 );
 
-Sentry.captureException(aggregateError);
+const shouldUseCustomMechanism = window.location.hash === '#custom-mechanism';
+
+if (shouldUseCustomMechanism) {
+  const cause = new Error('Failure 1');
+  const errorCause = new Error('Failure 2', { cause });
+  const error = new Error('Failure 3', { cause: errorCause });
+
+  Sentry.captureException(error, {
+    mechanism: { handled: false, type: 'auto.http.example' },
+  });
+} else {
+  Sentry.captureException(aggregateError);
+}

dev-packages/browser-integration-tests/suites/public-api/captureException/aggregateError-custom/test.ts

@@ -38,3 +38,45 @@ sentryTest('captures custom AggregateErrors', async ({ getLocalTestUrl, page })
     }),
   ]);
 });
+
+// fixme: the mechanism should be on the error
+sentryTest(
+  'keeps a custom capture mechanism on the captured error instead of its causes',
+  async ({ getLocalTestUrl, page }) => {
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const req = await waitForErrorRequestOnUrl(page, `${url}#custom-mechanism`);
+    const eventData = envelopeRequestParser(req);
+
+    expect(eventData.exception?.values).toHaveLength(3);
+    expect(eventData.exception?.values).toEqual([
+      expect.objectContaining({
+        value: 'Failure 1',
+        mechanism: {
+          exception_id: 2,
+          handled: false, // true,
+          parent_id: 1,
+          source: 'cause',
+          type: 'auto.http.example', // 'chained',
+        },
+      }),
+      expect.objectContaining({
+        value: 'Failure 2',
+        mechanism: {
+          exception_id: 1,
+          handled: true,
+          parent_id: 0,
+          source: 'cause',
+          type: 'chained',
+        },
+      }),
+      expect.objectContaining({
+        value: 'Failure 3',
+        mechanism: {
+          exception_id: 0,
+          handled: true, // false,
+          type: 'generic', // 'auto.http.example',
+        },
+      }),
+    ]);
+  },
+);

packages/core/test/lib/utils/aggregate-errors.test.ts

@@ -5,6 +5,7 @@ import type { Event, EventHint } from '../../../src/types/event';
 import type { Exception } from '../../../src/types/exception';
 import type { StackParser } from '../../../src/types/stacktrace';
 import { applyAggregateErrorsToEvent } from '../../../src/utils/aggregate-errors';
+import { addExceptionMechanism } from '../../../src/utils/misc';
 import { createStackParser } from '../../../src/utils/stacktrace';
 
 const stackParser = createStackParser([0, line => ({ filename: line })]);
@@ -116,6 +117,55 @@ describe('applyAggregateErrorsToEvent()', () => {
     });
   });
 
+  // fixme: the mechanism should be on the error
+  test('keeps a capture mechanism on the captured error instead of its causes', () => {
+    const cause = new Error('Failure 1');
+    const errorCause = new Error('Failure 2', { cause });
+    const error = new Error('Failure 3', { cause: errorCause });
+    const event: Event = { exception: { values: [exceptionFromError(stackParser, error)] } };
+    const eventHint: EventHint = {
+      originalException: error,
+      mechanism: { handled: false, type: 'auto.http.example' },
+    };
+
+    applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint);
+    addExceptionMechanism(event, eventHint.mechanism);
+
+    expect(event.exception?.values).toStrictEqual([
+      {
+        type: 'Error',
+        value: 'Failure 1',
+        mechanism: {
+          exception_id: 2,
+          handled: false, // true,
+          parent_id: 1,
+          source: 'cause',
+          type: 'auto.http.example', // 'chained',
+        },
+      },
+      {
+        type: 'Error',
+        value: 'Failure 2',
+        mechanism: {
+          exception_id: 1,
+          handled: true,
+          parent_id: 0,
+          source: 'cause',
+          type: 'chained',
+        },
+      },
+      {
+        type: 'Error',
+        value: 'Failure 3',
+        mechanism: {
+          exception_id: 0,
+          handled: true, //false,
+          type: 'instrument', //'auto.http.example',
+        },
+      },
+    ]);
+  });
+
   test('recursively walks errors created in another realm', () => {
     const originalException = runInNewContext(
       `new AggregateError([new Error('Aggregate child')], 'Root Error', { cause: new Error('Cause') })`,