Clean u

Author: Luca Forstner

packages/browser/src/integrations/linkederrors.ts

@@ -1,6 +1,5 @@
-import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
-import type { Event, EventHint, ExtendedError, Integration, StackParser } from '@sentry/types';
-import { aggreagateExceptionsFromError, isInstanceOf } from '@sentry/utils';
+import type { Event, EventHint, EventProcessor, Hub, Integration } from '@sentry/types';
+import { applyAggregateErrorsToEvent } from '@sentry/utils';
 
 import { exceptionFromError } from '../eventbuilder';
 
@@ -45,41 +44,26 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  public setupOnce(): void {
-    const client = getCurrentHub().getClient();
-    if (!client) {
-      return;
-    }
+  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
     addGlobalEventProcessor((event: Event, hint?: EventHint) => {
-      const self = getCurrentHub().getIntegration(LinkedErrors);
-      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;
-    });
-  }
-}
+      const hub = getCurrentHub();
+      const client = hub.getClient();
+      const self = hub.getIntegration(LinkedErrors);
 
-/**
- * @inheritDoc
- */
-export function _handler(
-  parser: StackParser,
-  key: string,
-  limit: number,
-  event: Event,
-  hint?: EventHint,
-): Event | null {
-  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
-    return event;
-  }
+      if (!client || !self) {
+        return event;
+      }
 
-  const linkedErrors = aggreagateExceptionsFromError(
-    exceptionFromError,
-    parser,
-    limit,
-    hint.originalException as ExtendedError,
-    key,
-  );
+      applyAggregateErrorsToEvent(
+        exceptionFromError,
+        client.getOptions().stackParser,
+        self._key,
+        self._limit,
+        event,
+        hint,
+      );
 
-  event.exception.values = [...linkedErrors, ...event.exception.values];
-
-  return event;
+      return event;
+    });
+  }
 }

packages/node/src/integrations/linkederrors.ts

@@ -1,6 +1,5 @@
-import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';
-import type { Event, EventHint, Exception, ExtendedError, Integration, StackParser } from '@sentry/types';
-import { isInstanceOf } from '@sentry/utils';
+import type { Event, EventHint, EventProcessor, Hub, Integration } from '@sentry/types';
+import { applyAggregateErrorsToEvent } from '@sentry/utils';
 
 import { exceptionFromError } from '../eventbuilder';
 import { ContextLines } from './contextlines';
@@ -41,15 +40,25 @@ export class LinkedErrors implements Integration {
   /**
    * @inheritDoc
    */
-  public setupOnce(): void {
-    addGlobalEventProcessor(async (event: Event, hint: EventHint) => {
+  public setupOnce(addGlobalEventProcessor: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
+    addGlobalEventProcessor(async (event: Event, hint?: EventHint) => {
       const hub = getCurrentHub();
-      const self = hub.getIntegration(LinkedErrors);
       const client = hub.getClient();
-      if (client && self && self._handler && typeof self._handler === 'function') {
-        self._handler(client.getOptions().stackParser, event, hint);
+      const self = hub.getIntegration(LinkedErrors);
+
+      if (!client || !self) {
+        return event;
       }
 
+      applyAggregateErrorsToEvent(
+        exceptionFromError,
+        client.getOptions().stackParser,
+        self._key,
+        self._limit,
+        event,
+        hint,
+      );
+
       // If the ContextLines integration is enabled, we add source code context to linked errors
       // because we can't guarantee the order that integrations are run.
       const contextLines = getCurrentHub().getIntegration(ContextLines);
@@ -60,35 +69,4 @@ export class LinkedErrors implements Integration {
       return event;
     });
   }
-
-  /**
-   * @inheritDoc
-   */
-  private _handler(stackParser: StackParser, event: Event, hint: EventHint): Event {
-    if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
-      return event;
-    }
-
-    const linkedErrors = this._walkErrorTree(stackParser, hint.originalException as ExtendedError, this._key);
-    event.exception.values = [...linkedErrors, ...event.exception.values];
-    return event;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  private _walkErrorTree(
-    stackParser: StackParser,
-    error: ExtendedError,
-    key: string,
-    stack: Exception[] = [],
-  ): Exception[] {
-    if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
-      return stack;
-    }
-
-    const exception = exceptionFromError(stackParser, error[key]);
-
-    return this._walkErrorTree(stackParser, error[key], key, [exception, ...stack]);
-  }
 }

packages/node/test/integrations/linkederrors.test.ts

@@ -6,17 +6,9 @@ import { LinkedErrors } from '../../src/integrations/linkederrors';
 import { defaultStackParser as stackParser } from '../../src/sdk';
 import { getDefaultNodeClientOptions } from '../helper/node-client-options';
 
-let linkedErrors: any;
-
 describe('LinkedErrors', () => {
-  beforeEach(() => {
-    linkedErrors = new LinkedErrors();
-  });
-
   describe('handler', () => {
     it('should bail out if event doesnt contain exception', async () => {
-      expect.assertions(2);
-      const spy = jest.spyOn(linkedErrors, '_walkErrorTree');
       const event = {
         message: 'foo',
       };

packages/utils/src/aggregate-errors.ts

@@ -1,11 +1,36 @@
-import type { Exception, ExtendedError, StackParser } from '@sentry/types';
+import type { Event, EventHint, Exception, ExtendedError, StackParser } from '@sentry/types';
 
 import { isInstanceOf } from './is';
 
 /**
  * TODO
  */
-export function aggreagateExceptionsFromError(
+export function applyAggregateErrorsToEvent(
+  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,
+  parser: StackParser,
+  key: string,
+  limit: number,
+  event: Event,
+  hint?: EventHint,
+): Event | null {
+  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
+    return event;
+  }
+
+  const linkedErrors = aggreagateExceptionsFromError(
+    exceptionFromErrorImplementation,
+    parser,
+    limit,
+    hint.originalException as ExtendedError,
+    key,
+  );
+
+  event.exception.values = [...linkedErrors, ...event.exception.values];
+
+  return event;
+}
+
+function aggreagateExceptionsFromError(
   exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,
   parser: StackParser,
   limit: number,