feat: Add synthetic to mechanism

Author: HazAT

packages/browser/src/backend.ts

@@ -64,7 +64,7 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
       const errorEvent = exception as ErrorEvent;
       exception = errorEvent.error; // tslint:disable-line:no-parameter-reassignment
       event = eventFromStacktrace(computeStackTrace(exception as Error));
-      return SyncPromise.resolve(this.buildEvent(event));
+      return SyncPromise.resolve(this.buildEvent(event, hint));
     } else if (isDOMError(exception as DOMError) || isDOMException(exception as DOMException)) {
       // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)
       // then we just extract the name and message, as they don't provide anything else
@@ -76,20 +76,20 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
 
       return this.eventFromMessage(message, Severity.Error, hint).then(messageEvent => {
         addExceptionTypeValue(messageEvent, message);
-        return SyncPromise.resolve(this.buildEvent(messageEvent));
+        return SyncPromise.resolve(this.buildEvent(messageEvent, hint));
       });
     } else if (isError(exception as Error)) {
       // we have a real Error object, do nothing
       event = eventFromStacktrace(computeStackTrace(exception as Error));
-      return SyncPromise.resolve(this.buildEvent(event));
+      return SyncPromise.resolve(this.buildEvent(event, hint));
     } else if (isPlainObject(exception as {}) && hint && hint.syntheticException) {
       // If it is plain Object, serialize it manually and extract options
       // This will allow us to group events based on top-level keys
       // which is much better than creating new group when any key/value change
       const objectException = exception as {};
       event = eventFromPlainObject(objectException, hint.syntheticException);
       addExceptionTypeValue(event, 'Custom Object');
-      return SyncPromise.resolve(this.buildEvent(event));
+      return SyncPromise.resolve(this.buildEvent(event, hint, true));
     }
 
     // If none of previous checks were valid, then it means that
@@ -101,21 +101,22 @@ export class BrowserBackend extends BaseBackend<BrowserOptions> {
     const stringException = exception as string;
     return this.eventFromMessage(stringException, undefined, hint).then(messageEvent => {
       addExceptionTypeValue(messageEvent, `${stringException}`);
-      return SyncPromise.resolve(this.buildEvent(messageEvent));
+      return SyncPromise.resolve(this.buildEvent(messageEvent, hint, true));
     });
   }
 
   /**
    * This is an internal helper function that creates an event.
    */
-  private buildEvent(event: Event, hint?: EventHint): Event {
+  private buildEvent(event: Event, hint?: EventHint, isSynthetic?: boolean): Event {
     return {
       ...event,
       event_id: hint && hint.event_id,
       exception: {
         ...event.exception,
         mechanism: {
           handled: true,
+          synthetic: isSynthetic,
           type: 'generic',
         },
       },

packages/node/src/backend.ts

@@ -1,5 +1,5 @@
 import { BaseBackend, Dsn, getCurrentHub } from '@sentry/core';
-import { Event, EventHint, Options, Severity, Transport } from '@sentry/types';
+import { Event, EventHint, Options, Mechanism, Severity, Transport } from '@sentry/types';
 import { isError, isPlainObject } from '@sentry/utils/is';
 import { normalizeToSize } from '@sentry/utils/object';
 import { keysToEventMessage } from '@sentry/utils/string';
@@ -76,7 +76,10 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
    */
   public eventFromException(exception: any, hint?: EventHint): SyncPromise<Event> {
     let ex: any = exception;
-
+    const mechanism: Mechanism = {
+      handled: true,
+      type: 'generic',
+    };
     if (!isError(exception)) {
       if (isPlainObject(exception)) {
         // This will allow us to group events based on top-level keys
@@ -100,13 +103,18 @@ export class NodeBackend extends BaseBackend<NodeOptions> {
         // We use synthesized Error here so we can extract a (rough) stack trace.
         ex = (hint && hint.syntheticException) || new Error(exception as string);
       }
+      mechanism.synthetic = true;
     }
 
     return new SyncPromise<Event>(resolve =>
       parseError(ex as Error, this.options).then(event => {
         resolve({
           ...event,
           event_id: hint && hint.event_id,
+          exception: {
+            ...event.exception,
+            mechanism,
+          },
         });
       }),
     );

packages/types/src/mechanism.ts

@@ -5,4 +5,5 @@ export interface Mechanism {
   data?: {
     [key: string]: string;
   };
+  synthetic?: boolean;
 }