feat: Make event processor async (#1431)

Author: HazAT

packages/core/src/base.ts

@@ -275,7 +275,10 @@ export abstract class BaseClient<B extends Backend, O extends Options>
     // This should be the last thing called, since we want that
     // {@link Hub.addEventProcessor} gets the finished prepared event.
     if (scope) {
-      scope.applyToEvent(prepared, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));
+      await scope.applyToEvent(
+        prepared,
+        Math.min(maxBreadcrumbs, MAX_BREADCRUMBS),
+      );
     }
 
     return prepared;
@@ -334,7 +337,6 @@ export abstract class BaseClient<B extends Backend, O extends Options>
     }
 
     // TODO: Handle duplicates and backoffs
-
     if (afterSend) {
       afterSend(finalEvent, response);
     }

packages/hub/src/hub.ts

@@ -216,10 +216,12 @@ export class Hub {
    * This will be called to receive the event
    * @param callback will only be called if there is a bound client
    */
-  public addEventProcessor(callback: () => (event: SentryEvent) => void): void {
+  public addEventProcessor(
+    callback: (event: SentryEvent) => Promise<void>,
+  ): void {
     const top = this.getStackTop();
     if (top.scope && top.client) {
-      top.scope.addEventProcessor(callback());
+      top.scope.addEventProcessor(callback);
     }
   }
 }

packages/hub/src/scope.ts

@@ -12,7 +12,7 @@ export class Scope {
   protected scopeListeners: Array<(scope: Scope) => void> = [];
 
   /** Callback list that will be called after {@link applyToEvent}. */
-  protected eventProcessors: Array<(scope: SentryEvent) => void> = [];
+  protected eventProcessors: Array<(scope: SentryEvent) => Promise<void>> = [];
 
   /** Array of breadcrumbs. */
   protected breadcrumbs: Breadcrumb[] = [];
@@ -35,7 +35,9 @@ export class Scope {
   }
 
   /** Add new event processor that will be called after {@link applyToEvent}. */
-  public addEventProcessor(callback: (scope: SentryEvent) => void): void {
+  public addEventProcessor(
+    callback: (scope: SentryEvent) => Promise<void>,
+  ): void {
     this.eventProcessors.push(callback);
   }
 
@@ -57,10 +59,11 @@ export class Scope {
   /**
    * This will be called after {@link applyToEvent} is finished.
    */
-  protected notifyEventProcessors(event: SentryEvent): void {
-    this.eventProcessors.forEach(callback => {
-      callback(event);
-    });
+  protected async notifyEventProcessors(event: SentryEvent): Promise<void> {
+    return this.eventProcessors.reduce(async (prev, callback) => {
+      await prev;
+      return callback(event);
+    }, Promise.resolve());
   }
 
   /**
@@ -164,7 +167,10 @@ export class Scope {
    * @param event SentryEvent
    * @param maxBreadcrumbs number of max breadcrumbs to merged into event.
    */
-  public applyToEvent(event: SentryEvent, maxBreadcrumbs?: number): void {
+  public async applyToEvent(
+    event: SentryEvent,
+    maxBreadcrumbs?: number,
+  ): Promise<void> {
     if (this.extra && Object.keys(this.extra).length) {
       event.extra = { ...this.extra, ...event.extra };
     }
@@ -189,6 +195,6 @@ export class Scope {
           : this.breadcrumbs;
     }
 
-    this.notifyEventProcessors(event);
+    await this.notifyEventProcessors(event);
   }
 }

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

@@ -226,24 +226,51 @@ describe('Hub', () => {
     });
   });
 
-  test('addEventProcessor', done => {
+  test('addEventProcessor', async done => {
     expect.assertions(2);
     const event: SentryEvent = {
       extra: { b: 3 },
     };
     const localScope = new Scope();
     localScope.setExtra('a', 'b');
     const hub = new Hub({ a: 'b' }, localScope);
-    hub.addEventProcessor(() => (processedEvent: SentryEvent) => {
+    hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       expect(processedEvent.extra).toEqual({ a: 'b', b: 3 });
     });
-    hub.addEventProcessor(() => (processedEvent: SentryEvent) => {
+    hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       processedEvent.dist = '1';
     });
-    hub.addEventProcessor(() => (processedEvent: SentryEvent) => {
+    hub.addEventProcessor(async (processedEvent: SentryEvent) => {
       expect(processedEvent.dist).toEqual('1');
       done();
     });
-    localScope.applyToEvent(event);
+    await localScope.applyToEvent(event);
+  });
+
+  test.only('addEventProcessor async', async done => {
+    expect.assertions(2);
+    const event: SentryEvent = {
+      extra: { b: 3 },
+    };
+    const localScope = new Scope();
+    localScope.setExtra('a', 'b');
+    const hub = new Hub({ a: 'b' }, localScope);
+    hub.addEventProcessor(async (processedEvent: SentryEvent) => {
+      expect(processedEvent.extra).toEqual({ a: 'b', b: 3 });
+    });
+    hub.addEventProcessor(
+      async (processedEvent: SentryEvent) =>
+        new Promise<void>(resolve => {
+          setImmediate(() => {
+            processedEvent.dist = '1';
+            resolve();
+          });
+        }),
+    );
+    hub.addEventProcessor(async (processedEvent: SentryEvent) => {
+      expect(processedEvent.dist).toEqual('1');
+      done();
+    });
+    await localScope.applyToEvent(event);
   });
 });

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

@@ -68,23 +68,23 @@ describe('Scope', () => {
     expect(listener.mock.calls[0][0].extra).toEqual({ a: 2 });
   });
 
-  test('applyToEvent', () => {
+  test('applyToEvent', async () => {
     const scope = new Scope();
     scope.setExtra('a', 2);
     scope.setTag('a', 'b');
     scope.setUser({ id: '1' });
     scope.setFingerprint(['abcd']);
     scope.addBreadcrumb({ message: 'test' }, 100);
     const event: SentryEvent = {};
-    scope.applyToEvent(event);
+    await scope.applyToEvent(event);
     expect(event.extra).toEqual({ a: 2 });
     expect(event.tags).toEqual({ a: 'b' });
     expect(event.user).toEqual({ id: '1' });
     expect(event.fingerprint).toEqual(['abcd']);
     expect(event.breadcrumbs).toEqual([{ message: 'test' }]);
   });
 
-  test('applyToEvent merge', () => {
+  test('applyToEvent merge', async () => {
     const scope = new Scope();
     scope.setExtra('a', 2);
     scope.setTag('a', 'b');
@@ -98,7 +98,7 @@ describe('Scope', () => {
       tags: { b: 'c' },
       user: { id: '3' },
     };
-    scope.applyToEvent(event);
+    await scope.applyToEvent(event);
     expect(event.extra).toEqual({ a: 2, b: 3 });
     expect(event.tags).toEqual({ a: 'b', b: 'c' });
     expect(event.user).toEqual({ id: '3' });