fix(core): Classify custom AggregateErrors as exception groups

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,40 @@
+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([
+    expect.objectContaining({
+      mechanism: { exception_id: 4, handled: true, parent_id: 0, source: 'errors[1]', type: 'chained' },
+      type: 'Error',
+      value: 'error 2',
+    }),
+    expect.objectContaining({
+      mechanism: { exception_id: 3, handled: true, parent_id: 2, source: 'cause', type: 'chained' },
+      type: 'Error',
+      value: 'error 1 cause',
+    }),
+    expect.objectContaining({
+      mechanism: { exception_id: 2, handled: true, parent_id: 0, source: 'errors[0]', type: 'chained' },
+      type: 'Error',
+      value: 'error 1',
+    }),
+    expect.objectContaining({
+      mechanism: { exception_id: 1, handled: true, parent_id: 0, source: 'cause', type: 'chained' },
+      type: 'Error',
+      value: 'aggregate cause',
+    }),
+    expect.objectContaining({
+      mechanism: { exception_id: 0, handled: true, type: 'generic', is_exception_group: true },
+      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);
@@ -74,10 +74,10 @@ function aggregateExceptionsFromError(
 
   // This will create exception grouping for AggregateErrors
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError
-  if (Array.isArray(error.errors)) {
+  if (isExceptionGroup(error)) {
     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,20 @@ function aggregateExceptionsFromError(
   return newExceptions;
 }
 
-function applyExceptionGroupFieldsForParentException(exception: Exception, exceptionId: number): void {
+function isExceptionGroup(error: ExtendedError): error is ExtendedError & { errors: unknown[] } {
+  return Array.isArray(error.errors);
+}
+
+function applyExceptionGroupFieldsForParentException(
+  exception: Exception,
+  exceptionId: number,
+  error: ExtendedError,
+): void {
   exception.mechanism = {
     handled: true,
     type: 'auto.core.linked_errors',
+    ...(isExceptionGroup(error) && { 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',
+          },
+        ],
+      },
+    });
+  });
 });