feat: Generate hint if not provided in the Hub calls (#2142)

Author: kamilogorek

packages/browser/src/index.ts

@@ -49,7 +49,7 @@ let windowIntegrations = {};
 
 // This block is needed to add compatibility with the integrations packages when used with a CDN
 // tslint:disable: no-unsafe-any
-const _window = getGlobalObject<Window>() as any;
+const _window = getGlobalObject<Window>();
 if (_window.Sentry && _window.Sentry.Integrations) {
   windowIntegrations = _window.Sentry.Integrations;
 }

packages/browser/src/sdk.ts

@@ -78,7 +78,7 @@ export function init(options: BrowserOptions = {}): void {
     options.defaultIntegrations = defaultIntegrations;
   }
   if (options.release === undefined) {
-    const window = getGlobalObject<Window>() as any;
+    const window = getGlobalObject<Window>();
     // This supports the variable that sentry-webpack-plugin injects
     if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {
       options.release = window.SENTRY_RELEASE.id;

packages/browser/test/index.test.ts

@@ -167,18 +167,16 @@ describe('SentryBrowser', () => {
   });
 });
 
-
 describe('SentryBrowser initialization', () => {
   it('should use window.SENTRY_RELEASE to set release on initialization if available', () => {
     global.SENTRY_RELEASE = { id: 'foobar' };
     init({ dsn });
     expect(global.__SENTRY__.hub._stack[0].client.getOptions().release).to.equal('foobar');
-    // Manually tear down global set. Is there a nicer way to do this?
-    global.SENTRY_RELEASE = undefined;
+    delete global.SENTRY_RELEASE;
   });
   it('should have initialization proceed as normal if window.SENTRY_RELEASE is not set', () => {
     // This is mostly a happy-path test to ensure that the initialization doesn't throw an error.
     init({ dsn });
     expect(global.__SENTRY__.hub._stack[0].client.getOptions().release).to.be.undefined;
   });
-})
+});

packages/hub/src/hub.ts

@@ -158,8 +158,27 @@ export class Hub implements HubInterface {
    */
   public captureException(exception: any, hint?: EventHint): string {
     const eventId = (this._lastEventId = uuid4());
+    let finalHint = hint;
+
+    // If there's no explicit hint provided, mimick the same thing that would happen
+    // in the minimal itself to create a consistent behavior.
+    // We don't do this in the client, as it's the lowest level API, and doing this,
+    // would prevent user from having full control over direct calls.
+    if (!hint) {
+      let syntheticException: Error;
+      try {
+        throw new Error('Sentry syntheticException');
+      } catch (exception) {
+        syntheticException = exception as Error;
+      }
+      finalHint = {
+        originalException: exception,
+        syntheticException,
+      };
+    }
+
     this._invokeClient('captureException', exception, {
-      ...hint,
+      ...finalHint,
       event_id: eventId,
     });
     return eventId;
@@ -170,8 +189,27 @@ export class Hub implements HubInterface {
    */
   public captureMessage(message: string, level?: Severity, hint?: EventHint): string {
     const eventId = (this._lastEventId = uuid4());
+    let finalHint = hint;
+
+    // If there's no explicit hint provided, mimick the same thing that would happen
+    // in the minimal itself to create a consistent behavior.
+    // We don't do this in the client, as it's the lowest level API, and doing this,
+    // would prevent user from having full control over direct calls.
+    if (!hint) {
+      let syntheticException: Error;
+      try {
+        throw new Error(message);
+      } catch (exception) {
+        syntheticException = exception as Error;
+      }
+      finalHint = {
+        originalException: message,
+        syntheticException,
+      };
+    }
+
     this._invokeClient('captureMessage', message, level, {
-      ...hint,
+      ...finalHint,
       event_id: eventId,
     });
     return eventId;

packages/hub/test/hub.test.ts

@@ -212,6 +212,25 @@ describe('Hub', () => {
     expect(eventId).toBe(hub.lastEventId());
   });
 
+  test('captureException should generate hint if not provided in the call', () => {
+    const hub = new Hub();
+    const spy = jest.spyOn(hub as any, '_invokeClient');
+    const ex = new Error('foo');
+    hub.captureException(ex);
+    expect(spy.mock.calls[0][2].originalException).toBe(ex);
+    expect(spy.mock.calls[0][2].syntheticException).toBeInstanceOf(Error);
+    expect(spy.mock.calls[0][2].syntheticException.message).toBe('Sentry syntheticException');
+  });
+
+  test('captureMessage should generate hint if not provided in the call', () => {
+    const hub = new Hub();
+    const spy = jest.spyOn(hub as any, '_invokeClient');
+    hub.captureMessage('foo');
+    expect(spy.mock.calls[0][3].originalException).toBe('foo');
+    expect(spy.mock.calls[0][3].syntheticException).toBeInstanceOf(Error);
+    expect(spy.mock.calls[0][3].syntheticException.message).toBe('foo');
+  });
+
   test('run', () => {
     const currentHub = getCurrentHub();
     const myScope = new Scope();

packages/integrations/src/extraerrordata.ts

@@ -44,7 +44,7 @@ export class ExtraErrorData implements Integration {
       return event;
     }
 
-    const errorData = this._extractErrorData(hint.originalException);
+    const errorData = this._extractErrorData(hint.originalException as ExtendedError);
 
     if (errorData) {
       let extra = {

packages/node/src/sdk.ts

@@ -86,7 +86,7 @@ export function init(options: NodeOptions = {}): void {
   }
 
   if (options.release === undefined) {
-    const global = getGlobalObject<Window>() as any;
+    const global = getGlobalObject<Window>();
     // Prefer env var over global
     if (process.env.SENTRY_RELEASE) {
       options.release = process.env.SENTRY_RELEASE;

packages/node/test/index.test.ts

@@ -252,4 +252,4 @@ describe('SentryNode initialization', () => {
     init({ dsn });
     expect(global.__SENTRY__.hub._stack[0].client.getOptions().release).toBeUndefined();
   });
-})
+});

packages/types/src/event.ts

@@ -42,6 +42,6 @@ export type EventType = 'none';
 export interface EventHint {
   event_id?: string;
   syntheticException?: Error | null;
-  originalException?: Error | null;
+  originalException?: Error | string | null;
   data?: any;
 }

packages/types/src/options.ts

@@ -66,7 +66,7 @@ export interface Options {
   /** Sets the distribution for all events */
   dist?: string;
 
-  /** 
+  /**
    * The maximum number of breadcrumbs sent with events. Defaults to 30.
    * Values over 100 will be ignored and 100 used instead.
    */