fix(core): Identify custom AggregateErrors as exception groups

Author: Lms24

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

@@ -0,0 +1,16 @@
+class CustomAggregateError extends AggregateError {
+  constructor(errors, message, options) {
+    super(errors, message, options);
+    this.name = 'CustomAggregateError';
+  }
+}
+
+const aggregateError = new CustomAggregateError(
+  [new Error('error 1', { cause: new Error('error 1 cause') }), new Error('error 2')],
+  'custom aggregate error',
+  {
+      cause: new Error('aggregate cause'),
+  },
+);
+
+Sentry.captureException(aggregateError);

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

@@ -0,0 +1,70 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, waitForErrorRequestOnUrl } from '../../../../utils/helpers';
+
+sentryTest('captures custom AggregateErrors', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const req = await waitForErrorRequestOnUrl(page, url);
+  const eventData = envelopeRequestParser(req);
+
+  expect(eventData.exception?.values).toHaveLength(5); // CustomAggregateError + 3 embedded errors + 1 aggregate cause
+
+  // Verify the embedded errors come first
+  expect(eventData.exception?.values).toEqual([
+    {
+      mechanism: { exception_id: 4, handled: true, parent_id: 0, source: 'errors[1]', type: 'chained' },
+      stacktrace: {
+        frames: [
+          { colno: 12, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 14 },
+          { colno: 5, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 10 },
+        ],
+      },
+      type: 'Error',
+      value: 'error 2',
+    },
+    {
+      mechanism: { exception_id: 3, handled: true, parent_id: 2, source: 'cause', type: 'chained' },
+      stacktrace: {
+        frames: [
+          { colno: 12, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 14 },
+          { colno: 10, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 9 },
+        ],
+      },
+      type: 'Error',
+      value: 'error 1 cause',
+    },
+    {
+      mechanism: { exception_id: 2, handled: true, parent_id: 0, source: 'errors[0]', type: 'chained' },
+      stacktrace: {
+        frames: [
+          { colno: 12, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 14 },
+          { colno: 50, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 8 },
+        ],
+      },
+      type: 'Error',
+      value: 'error 1',
+    },
+    {
+      mechanism: { exception_id: 1, handled: true, parent_id: 0, source: 'cause', type: 'chained' },
+      stacktrace: {
+        frames: [
+          { colno: 12, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 14 },
+          { colno: 10, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 11 },
+        ],
+      },
+      type: 'Error',
+      value: 'aggregate cause',
+    },
+    {
+      mechanism: { exception_id: 0, handled: true, type: 'generic', is_exception_group: true },
+      stacktrace: {
+        frames: [
+          { colno: 12, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 14 },
+          { colno: 24, filename: 'http://sentry-test.io/subject.bundle.js', function: '?', in_app: true, lineno: 8 },
+        ],
+      },
+      type: 'CustomAggregateError',
+      value: 'custom aggregate error',
+    },
+  ]);
+});

packages/core/src/utils/aggregate-errors.ts

@@ -56,7 +56,7 @@ function aggregateExceptionsFromError(
 
   // Recursively call this function in order to walk down a chain of errors
   if (isInstanceOf(error[key], Error)) {
-    applyExceptionGroupFieldsForParentException(exception, exceptionId);
+    applyExceptionGroupFieldsForParentException(exception, exceptionId, error);
     const newException = exceptionFromErrorImplementation(parser, error[key] as Error);
     const newExceptionId = newExceptions.length;
     applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);
@@ -77,7 +77,7 @@ function aggregateExceptionsFromError(
   if (Array.isArray(error.errors)) {
     error.errors.forEach((childError, i) => {
       if (isInstanceOf(childError, Error)) {
-        applyExceptionGroupFieldsForParentException(exception, exceptionId);
+        applyExceptionGroupFieldsForParentException(exception, exceptionId, error);
         const newException = exceptionFromErrorImplementation(parser, childError as Error);
         const newExceptionId = newExceptions.length;
         applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);
@@ -98,12 +98,16 @@ function aggregateExceptionsFromError(
   return newExceptions;
 }
 
-function applyExceptionGroupFieldsForParentException(exception: Exception, exceptionId: number): void {
+function applyExceptionGroupFieldsForParentException(
+  exception: Exception,
+  exceptionId: number,
+  error: ExtendedError,
+): void {
   exception.mechanism = {
     handled: true,
     type: 'auto.core.linked_errors',
+    ...(Array.isArray(error.errors) && { is_exception_group: true }),
     ...exception.mechanism,
-    ...(exception.type === 'AggregateError' && { is_exception_group: true }),
     exception_id: exceptionId,
   };
 }

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

@@ -20,6 +20,16 @@ class FakeAggregateError extends Error {
   }
 }
 
+class CustomAggregateError extends FakeAggregateError {
+  public cause?: Error;
+
+  constructor(errors: Error[], message: string, cause?: Error) {
+    super(errors, message);
+    this.name = 'CustomAggregateError';
+    this.cause = cause;
+  }
+}
+
 describe('applyAggregateErrorsToEvent()', () => {
   test('should not do anything if event does not contain an exception', () => {
     const event: Event = { exception: undefined };
@@ -316,4 +326,56 @@ describe('applyAggregateErrorsToEvent()', () => {
       },
     });
   });
+
+  test('marks custom AggregateErrors as exception groups', () => {
+    const customAggregateError = new CustomAggregateError(
+      [new Error('Nested Error 1')],
+      'my CustomAggregateError',
+      new Error('Aggregate Cause'),
+    );
+
+    const event: Event = { exception: { values: [exceptionFromError(stackParser, customAggregateError)] } };
+    const eventHint: EventHint = { originalException: customAggregateError };
+
+    applyAggregateErrorsToEvent(exceptionFromError, stackParser, 'cause', 100, event, eventHint);
+
+    expect(event).toStrictEqual({
+      exception: {
+        values: [
+          {
+            mechanism: {
+              exception_id: 2,
+              handled: true,
+              parent_id: 0,
+              source: 'errors[0]',
+              type: 'chained',
+            },
+            type: 'Error',
+            value: 'Nested Error 1',
+          },
+          {
+            mechanism: {
+              exception_id: 1,
+              handled: true,
+              parent_id: 0,
+              source: 'cause',
+              type: 'chained',
+            },
+            type: 'Error',
+            value: 'Aggregate Cause',
+          },
+          {
+            mechanism: {
+              exception_id: 0,
+              handled: true,
+              type: 'instrument',
+              is_exception_group: true,
+            },
+            type: 'CustomAggregateError',
+            value: 'my CustomAggregateError',
+          },
+        ],
+      },
+    });
+  });
 });