feat: Return event_id from capture calls

Author: HazAT

packages/browser/src/backend.ts

@@ -97,6 +97,7 @@ export class BrowserBackend implements Backend {
 
     event = {
       ...event,
+      event_id: hint && hint.event_id,
       exception: {
         ...event.exception,
         mechanism: {
@@ -114,6 +115,7 @@ export class BrowserBackend implements Backend {
    */
   public async eventFromMessage(message: string, level?: Severity, hint?: SentryEventHint): Promise<SentryEvent> {
     const event: SentryEvent = {
+      event_id: hint && hint.event_id,
       fingerprint: [message],
       level,
       message,

packages/browser/test/index.test.ts

@@ -12,6 +12,7 @@ import {
   init,
   Scope,
   SentryEvent,
+  Status,
 } from '../src';
 
 const dsn = 'https://[email protected]/4291';
@@ -64,7 +65,7 @@ describe('SentryBrowser', () => {
     let s: sinon.SinonStub;
 
     beforeEach(() => {
-      s = stub(BrowserBackend.prototype, 'sendEvent').returns(Promise.resolve(200));
+      s = stub(BrowserBackend.prototype, 'sendEvent').returns(Promise.resolve({ status: Status.Success }));
     });
 
     afterEach(() => {
@@ -96,7 +97,7 @@ describe('SentryBrowser', () => {
     let s: sinon.SinonStub;
 
     beforeEach(() => {
-      s = stub(BrowserBackend.prototype, 'sendEvent').returns(Promise.resolve(200));
+      s = stub(BrowserBackend.prototype, 'sendEvent').returns(Promise.resolve({ status: Status.Success }));
     });
 
     afterEach(() => {

packages/core/src/base.ts

@@ -116,17 +116,22 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
   /**
    * @inheritDoc
    */
-  public async captureException(exception: any, hint?: SentryEventHint, scope?: Scope): Promise<void> {
+  public async captureException(exception: any, hint?: SentryEventHint, scope?: Scope): Promise<SentryResponse> {
     const event = await this.getBackend().eventFromException(exception, hint);
-    await this.captureEvent(event, hint, scope);
+    return this.captureEvent(event, hint, scope);
   }
 
   /**
    * @inheritDoc
    */
-  public async captureMessage(message: string, level?: Severity, hint?: SentryEventHint, scope?: Scope): Promise<void> {
+  public async captureMessage(
+    message: string,
+    level?: Severity,
+    hint?: SentryEventHint,
+    scope?: Scope,
+  ): Promise<SentryResponse> {
     const event = await this.getBackend().eventFromMessage(message, level, hint);
-    await this.captureEvent(event, hint, scope);
+    return this.captureEvent(event, hint, scope);
   }
 
   /**
@@ -225,7 +230,9 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
       request.url = truncate(request.url, MAX_URL_LENGTH);
     }
 
-    prepared.event_id = uuid4();
+    if (prepared.event_id === undefined) {
+      prepared.event_id = uuid4();
+    }
 
     // This should be the last thing called, since we want that
     // {@link Hub.addEventProcessor} gets the finished prepared event.
@@ -287,7 +294,9 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
         status: Status.Skipped,
       };
     }
+
     const response = await send(finalEvent);
+    response.event = finalEvent;
 
     if (response.status === Status.RateLimit) {
       // TODO: Handle rate limits and maintain a queue. For now, we require SDK

packages/core/src/interfaces.ts

@@ -139,9 +139,9 @@ export interface Client<O extends Options = Options> {
    * @param exception An exception-like object.
    * @param hint May contain additional informartion about the original exception.
    * @param scope An optional scope containing event metadata.
-   * @returns The created event id.
+   * @returns SentryResponse status and event
    */
-  captureException(exception: any, hint?: SentryEventHint, scope?: Scope): Promise<void>;
+  captureException(exception: any, hint?: SentryEventHint, scope?: Scope): Promise<SentryResponse>;
 
   /**
    * Captures a message event and sends it to Sentry.
@@ -150,17 +150,17 @@ export interface Client<O extends Options = Options> {
    * @param level Define the level of the message.
    * @param hint May contain additional informartion about the original exception.
    * @param scope An optional scope containing event metadata.
-   * @returns The created event id.
+   * @returns SentryResponse status and event
    */
-  captureMessage(message: string, level?: Severity, hint?: SentryEventHint, scope?: Scope): Promise<void>;
+  captureMessage(message: string, level?: Severity, hint?: SentryEventHint, scope?: Scope): Promise<SentryResponse>;
 
   /**
    * Captures a manually created event and sends it to Sentry.
    *
    * @param event The event to send to Sentry.
    * @param hint May contain additional informartion about the original exception.
    * @param scope An optional scope containing event metadata.
-   * @returns The created event id.
+   * @returns SentryResponse status and event
    */
   captureEvent(event: SentryEvent, hint?: SentryEventHint, scope?: Scope): Promise<SentryResponse>;
 

packages/hub/src/hub.ts

@@ -1,4 +1,5 @@
 import { Breadcrumb, SentryEvent, SentryEventHint, Severity } from '@sentry/types';
+import { uuid4 } from '@sentry/utils/misc';
 import { Layer } from './interfaces';
 import { Scope } from './scope';
 
@@ -8,7 +9,7 @@ import { Scope } from './scope';
  * WARNING: This number should only be incresed when the global interface
  * changes a and new methods are introduced.
  */
-export const API_VERSION = 2;
+export const API_VERSION = 3;
 
 /**
  * Internal class used to make sure we always have the latest internal functions
@@ -165,9 +166,15 @@ export class Hub {
    *
    * @param exception An exception-like object.
    * @param hint May contain additional informartion about the original exception.
+   * @returns The generated eventId.
    */
-  public captureException(exception: any, hint?: SentryEventHint): void {
-    this.invokeClientAsync('captureException', exception, hint);
+  public captureException(exception: any, hint?: SentryEventHint): string {
+    const eventId = uuid4();
+    this.invokeClientAsync('captureException', exception, {
+      ...hint,
+      event_id: eventId,
+    });
+    return eventId;
   }
 
   /**
@@ -176,18 +183,28 @@ export class Hub {
    * @param message The message to send to Sentry.
    * @param level Define the level of the message.
    * @param hint May contain additional informartion about the original exception.
+   * @returns The generated eventId.
    */
-  public captureMessage(message: string, level?: Severity, hint?: SentryEventHint): void {
-    this.invokeClientAsync('captureMessage', message, level, hint);
+  public captureMessage(message: string, level?: Severity, hint?: SentryEventHint): string {
+    const eventId = uuid4();
+    this.invokeClientAsync('captureMessage', message, level, {
+      ...hint,
+      event_id: eventId,
+    });
+    return eventId;
   }
 
   /**
    * Captures a manually created event and sends it to Sentry.
    *
    * @param event The event to send to Sentry.
    */
-  public captureEvent(event: SentryEvent): void {
-    this.invokeClientAsync('captureEvent', event);
+  public captureEvent(event: SentryEvent): string {
+    const eventId = uuid4();
+    this.invokeClientAsync('captureEvent', event, {
+      event_id: eventId,
+    });
+    return eventId;
   }
 
   /**

packages/hub/test/lib/hub.test.ts

@@ -247,4 +247,28 @@ describe('Hub', () => {
       expect(final!.dist).toEqual('1');
     }
   });
+
+  test('captureException should set event_id in hint', () => {
+    const hub = new Hub();
+    const spy = jest.spyOn(hub as any, 'invokeClientAsync');
+    hub.captureException('a');
+    expect(spy.mock.calls[0][2]!.event_id).toBeTruthy();
+  });
+
+  test('captureMessage should set event_id in hint', () => {
+    const hub = new Hub();
+    const spy = jest.spyOn(hub as any, 'invokeClientAsync');
+    hub.captureMessage('a');
+    expect(spy.mock.calls[0][3]!.event_id).toBeTruthy();
+  });
+
+  test('captureEvent should set event_id in hint', () => {
+    const event: SentryEvent = {
+      extra: { b: 3 },
+    };
+    const hub = new Hub();
+    const spy = jest.spyOn(hub as any, 'invokeClientAsync');
+    hub.captureEvent(event);
+    expect(spy.mock.calls[0][2]!.event_id).toBeTruthy();
+  });
 });

packages/minimal/src/index.ts

@@ -6,51 +6,55 @@ import { Breadcrumb, SentryEvent, Severity } from '@sentry/types';
  * @param method function to call on hub.
  * @param args to pass to function.
  */
-function callOnHub(method: string, ...args: any[]): void {
+function callOnHub<T>(method: string, ...args: any[]): T {
   const hub = getCurrentHub();
   if (hub && hub[method as keyof Hub]) {
-    (hub[method as keyof Hub] as any)(...args);
+    return (hub[method as keyof Hub] as any)(...args);
   }
+  throw new Error(`No hub defined or ${method} was not found on the hub, please open a bug report.`);
 }
 
 /**
  * Captures an exception event and sends it to Sentry.
  *
  * @param exception An exception-like object.
+ * @returns The generated eventId.
  */
-export function captureException(exception: any): void {
+export function captureException(exception: any): string {
   let syntheticException: Error;
   try {
     throw new Error('Sentry syntheticException');
   } catch (exception) {
     syntheticException = exception as Error;
   }
-  callOnHub('captureException', exception, { syntheticException });
+  return callOnHub('captureException', exception, { syntheticException });
 }
 
 /**
  * Captures a message event and sends it to Sentry.
  *
  * @param message The message to send to Sentry.
  * @param level Define the level of the message.
+ * @returns The generated eventId.
  */
-export function captureMessage(message: string, level?: Severity): void {
+export function captureMessage(message: string, level?: Severity): string {
   let syntheticException: Error;
   try {
     throw new Error(message);
   } catch (exception) {
     syntheticException = exception as Error;
   }
-  callOnHub('captureMessage', message, level, { syntheticException });
+  return callOnHub('captureMessage', message, level, { syntheticException });
 }
 
 /**
  * Captures a manually created event and sends it to Sentry.
  *
  * @param event The event to send to Sentry.
+ * @returns The generated eventId.
  */
-export function captureEvent(event: SentryEvent): void {
-  callOnHub('captureEvent', event);
+export function captureEvent(event: SentryEvent): string {
+  return callOnHub('captureEvent', event);
 }
 
 /**

packages/minimal/test/lib/minimal.test.ts

@@ -19,6 +19,18 @@ describe('Minimal', () => {
   });
 
   describe('Capture', () => {
+    test('Return an event_id', () => {
+      const client = {
+        captureException: jest.fn(async () => Promise.resolve()),
+      };
+      getCurrentHub().withScope(() => {
+        getCurrentHub().bindClient(client);
+        const e = new Error('test exception');
+        const eventId = captureException(e);
+        expect(eventId).toBeTruthy();
+      });
+    });
+
     test('Exception', () => {
       const client = {
         captureException: jest.fn(async () => Promise.resolve()),

packages/node/src/backend.ts

@@ -53,14 +53,18 @@ export class NodeBackend implements Backend {
 
     const event: SentryEvent = await parseError(ex as Error);
 
-    return event;
+    return {
+      ...event,
+      event_id: hint && hint.event_id,
+    };
   }
 
   /**
    * @inheritDoc
    */
   public async eventFromMessage(message: string, level?: Severity, hint?: SentryEventHint): Promise<SentryEvent> {
     const event: SentryEvent = {
+      event_id: hint && hint.event_id,
       fingerprint: [message],
       level,
       message,

packages/types/src/index.ts

@@ -210,6 +210,7 @@ export interface Integration {
 /** JSDoc */
 export interface SentryResponse {
   status: Status;
+  event?: SentryEvent;
 }
 
 /** JSDoc */
@@ -284,6 +285,7 @@ export interface SentryWrappedFunction extends Function {
 
 /** JSDoc */
 export interface SentryEventHint {
+  event_id?: string;
   syntheticException?: Error | null;
   originalException?: Error | null;
   data?: any;

yarn.lock

@@ -1979,6 +1979,10 @@ colors@^1.1.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.0.tgz#5f20c9fef6945cb1134260aab33bfbdc8295e04e"
 
+colors@~0.6.0:
+  version "0.6.2"
+  resolved "https://registry.yarnpkg.com/colors/-/colors-0.6.2.tgz#2423fe6678ac0c5dae8852e5d0e5be08c997abcc"
+
 columnify@^1.5.4:
   version "1.5.4"
   resolved "https://registry.yarnpkg.com/columnify/-/columnify-1.5.4.tgz#4737ddf1c7b69a8a7c340570782e947eec8e78bb"
@@ -4604,6 +4608,16 @@ karma-coverage@^1.1.1:
     minimatch "^3.0.0"
     source-map "^0.5.1"
 
+[email protected]:
+  version "0.0.3"
+  resolved "https://registry.yarnpkg.com/karma-failed-reporter/-/karma-failed-reporter-0.0.3.tgz#4532ec9652c9fe297d0b72d08d9cade9725ef733"
+  dependencies:
+    colors "~0.6.0"
+
+karma-firefox-launcher@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/karma-firefox-launcher/-/karma-firefox-launcher-1.1.0.tgz#2c47030452f04531eb7d13d4fc7669630bb93339"
+
 karma-mocha-reporter@^2.2.5:
   version "2.2.5"
   resolved "https://registry.yarnpkg.com/karma-mocha-reporter/-/karma-mocha-reporter-2.2.5.tgz#15120095e8ed819186e47a0b012f3cd741895560"