feat: core ExtraErrorData integration (#1778)

Author: kamilogorek

packages/browser/src/sdk.ts

@@ -8,6 +8,7 @@ export const defaultIntegrations = [
   new CoreIntegrations.Dedupe(),
   new CoreIntegrations.InboundFilters(),
   new CoreIntegrations.FunctionToString(),
+  new CoreIntegrations.ExtraErrorData(),
   // Native Wrappers
   new TryCatch(),
   new Breadcrumbs(),

packages/core/src/integrations/extraerrordata.ts

@@ -0,0 +1,89 @@
+import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';
+import { Integration, SentryEvent, SentryEventHint } from '@sentry/types';
+import { isError } from '@sentry/utils/is';
+import { logger } from '../../../utils/logger';
+
+/**
+ * Just an Error object with arbitrary attributes attached to it.
+ */
+interface ExtendedError extends Error {
+  [key: string]: unknown;
+}
+
+/** Patch toString calls to return proper name for wrapped functions */
+export class ExtraErrorData implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public name: string = ExtraErrorData.id;
+
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'ExtraErrorData';
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(): void {
+    addGlobalEventProcessor(async (event: SentryEvent, hint?: SentryEventHint) => {
+      const self = getCurrentHub().getIntegration(ExtraErrorData);
+
+      if (!self || !hint || !hint.originalException) {
+        return event;
+      }
+
+      return this.enhanceEventWithErrorData(event, hint.originalException);
+    });
+  }
+
+  /**
+   * Attaches extracted information from the Error object to extra field in the SentryEvent
+   */
+  public enhanceEventWithErrorData(event: SentryEvent, error: Error): SentryEvent {
+    const errorData = this.extractErrorData(error);
+
+    if (errorData) {
+      return {
+        ...event,
+        extra: {
+          ...event.extra,
+          ...errorData,
+        },
+      };
+    }
+
+    return event;
+  }
+
+  /**
+   * Extract extra information from the Error object
+   */
+  private extractErrorData(error: ExtendedError): { [key: string]: unknown } | null {
+    // We are trying to enhance already existing event, so no harm done if it won't succeed
+    try {
+      const nativeKeys = ['name', 'message', 'stack', 'line', 'column', 'fileName', 'lineNumber', 'columnNumber'];
+      const name = error.name || error.constructor.name;
+      const errorKeys = Object.keys(error).filter(key => nativeKeys.indexOf(key) === -1);
+
+      if (errorKeys.length) {
+        const extraErrorInfo: { [key: string]: unknown } = {};
+        for (const key of errorKeys) {
+          let value = error[key];
+          if (isError(value)) {
+            value = (value as Error).name || (value as Error).constructor.name;
+          }
+          extraErrorInfo[key] = value;
+        }
+        return {
+          [name]: extraErrorInfo,
+        };
+      }
+
+      return null;
+    } catch (oO) {
+      logger.error('Unable to extract extra data from the Error object:', oO);
+      return null;
+    }
+  }
+}

packages/core/src/integrations/index.ts

@@ -2,6 +2,7 @@ export { Dedupe } from './dedupe';
 export { FunctionToString } from './functiontostring';
 export { SDKInformation } from './sdkinformation';
 export { InboundFilters } from './inboundfilters';
+export { ExtraErrorData } from './extraerrordata';
 
 export { Debug } from './pluggable/debug';
 export { RewriteFrames } from './pluggable/rewriteframes';

packages/core/test/lib/integrations/extraerrordata.test.ts

@@ -0,0 +1,65 @@
+import { SentryEvent } from '@sentry/types';
+import { ExtraErrorData } from '../../../src/integrations/extraerrordata';
+
+/**
+ * Just an Error object with arbitrary attributes attached to it.
+ */
+interface ExtendedError extends Error {
+  [key: string]: any;
+}
+
+const extraErrorData = new ExtraErrorData();
+let event: SentryEvent;
+
+describe('ExtraErrorData()', () => {
+  beforeEach(() => {
+    event = {};
+  });
+
+  it('should enhance event with extra data extracted from the error', () => {
+    const error = new TypeError('foo') as ExtendedError;
+    error.baz = 42;
+    error.foo = 'bar';
+
+    const enhancedEvent = extraErrorData.enhanceEventWithErrorData(event, error);
+
+    expect(enhancedEvent.extra).toEqual({
+      TypeError: {
+        baz: 42,
+        foo: 'bar',
+      },
+    });
+  });
+
+  it('doesnt choke on linked errors and stringify names instead', () => {
+    const error = new TypeError('foo') as ExtendedError;
+    error.cause = new SyntaxError('bar');
+
+    const enhancedEvent = extraErrorData.enhanceEventWithErrorData(event, error);
+
+    expect(enhancedEvent.extra).toEqual({
+      TypeError: {
+        cause: 'SyntaxError',
+      },
+    });
+  });
+
+  it('should not remove previous data existing in extra field', () => {
+    event = {
+      extra: {
+        foo: 42,
+      },
+    };
+    const error = new TypeError('foo') as ExtendedError;
+    error.baz = 42;
+
+    const enhancedEvent = extraErrorData.enhanceEventWithErrorData(event, error);
+
+    expect(enhancedEvent.extra).toEqual({
+      TypeError: {
+        baz: 42,
+      },
+      foo: 42,
+    });
+  });
+});

packages/node/src/parsers.ts

@@ -193,25 +193,12 @@ export async function getExceptionFromError(error: Error): Promise<SentryExcepti
 export async function parseError(error: ExtendedError): Promise<SentryEvent> {
   const name = error.name || error.constructor.name;
   const exception = await getExceptionFromError(error);
-  const event: SentryEvent = {
+  return {
     exception: {
       values: [exception],
     },
     message: `${name}: ${error.message || '<no message>'}`,
   };
-  const errorKeys = Object.keys(error).filter(key => !(key in ['name', 'message', 'stack', 'domain']));
-
-  if (errorKeys.length) {
-    const extraErrorInfo: { [key: string]: any } = {};
-    for (const key of errorKeys) {
-      extraErrorInfo[key] = error[key];
-    }
-    event.extra = {
-      [name]: extraErrorInfo,
-    };
-  }
-
-  return event;
 }
 
 /** JSDoc */

packages/node/src/sdk.ts

@@ -10,6 +10,7 @@ export const defaultIntegrations = [
   new CoreIntegrations.Dedupe(),
   new CoreIntegrations.InboundFilters(),
   new CoreIntegrations.FunctionToString(),
+  new CoreIntegrations.ExtraErrorData(),
   // Native Wrappers
   new Console(),
   new Http(),
@@ -83,4 +84,4 @@ export function init(options: NodeOptions = {}): void {
  */
 export function lastEventId(): string | undefined {
   return getCurrentHub().lastEventId();
-}
+}