feat(core): Introduce processEvent hook on Integration

packages/core/src/baseclient.ts

@@ -12,6 +12,7 @@ import type {
   Event,
   EventDropReason,
   EventHint,
+  EventProcessor,
   Integration,
   IntegrationClass,
   Outcome,
@@ -107,6 +108,8 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
   // eslint-disable-next-line @typescript-eslint/ban-types
   private _hooks: Record<string, Function[]>;
 
+  private _eventProcessors: EventProcessor[];
+
   /**
    * Initializes this client instance.
    *
@@ -119,6 +122,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     this._numProcessing = 0;
     this._outcomes = {};
     this._hooks = {};
+    this._eventProcessors = [];
 
     if (options.dsn) {
       this._dsn = makeDsn(options.dsn);
@@ -280,6 +284,16 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     });
   }
 
+  /** Get all installed event processors. */
+  public getEventProcessors(): EventProcessor[] {
+    return this._eventProcessors;
+  }
+
+  /** @inheritDoc */
+  public addEventProcessor(eventProcessor: EventProcessor): void {
+    this._eventProcessors.push(eventProcessor);
+  }
+
   /**
    * Sets up the integrations
    */
@@ -545,7 +559,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
 
     this.emit('preprocessEvent', event, hint);
 
-    return prepareEvent(options, event, hint, scope).then(evt => {
+    return prepareEvent(options, event, hint, scope, this).then(evt => {
       if (evt === null) {
         return evt;
       }

packages/core/src/eventProcessors.ts

@@ -0,0 +1,51 @@
+import type { Event, EventHint, EventProcessor } from '@sentry/types';
+import { getGlobalSingleton, isThenable, logger, SyncPromise } from '@sentry/utils';
+
+/**
+ * Returns the global event processors.
+ */
+export function getGlobalEventProcessors(): EventProcessor[] {
+  return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);
+}
+
+/**
+ * Add a EventProcessor to be kept globally.
+ * @param callback EventProcessor to add
+ */
+export function addGlobalEventProcessor(callback: EventProcessor): void {
+  getGlobalEventProcessors().push(callback);
+}
+
+/**
+ * Process an array of event processors, returning the processed event (or `null` if the event was dropped).
+ */
+export function notifyEventProcessors(
+  processors: EventProcessor[],
+  event: Event | null,
+  hint: EventHint,
+  index: number = 0,
+): PromiseLike<Event | null> {
+  return new SyncPromise<Event | null>((resolve, reject) => {
+    const processor = processors[index];
+    if (event === null || typeof processor !== 'function') {
+      resolve(event);
+    } else {
+      const result = processor({ ...event }, hint) as Event | null;
+
+      __DEBUG_BUILD__ &&
+        processor.id &&
+        result === null &&
+        logger.log(`Event processor "${processor.id}" dropped event`);
+
+      if (isThenable(result)) {
+        void result
+          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))
+          .then(null, reject);
+      } else {
+        void notifyEventProcessors(processors, result, hint, index + 1)
+          .then(resolve)
+          .then(null, reject);
+      }
+    }
+  });
+}

packages/core/src/index.ts

@@ -36,7 +36,8 @@ export {
 } from './hub';
 export { makeSession, closeSession, updateSession } from './session';
 export { SessionFlusher } from './sessionflusher';
-export { addGlobalEventProcessor, Scope } from './scope';
+export { Scope } from './scope';
+export { addGlobalEventProcessor } from './eventProcessors';
 export { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint } from './api';
 export { BaseClient } from './baseclient';
 export { ServerRuntimeClient } from './server-runtime-client';

packages/core/src/integration.ts

@@ -1,8 +1,8 @@
-import type { Client, Integration, Options } from '@sentry/types';
+import type { Client, Event, EventHint, Integration, Options } from '@sentry/types';
 import { arrayify, logger } from '@sentry/utils';
 
+import { addGlobalEventProcessor } from './eventProcessors';
 import { getCurrentHub } from './hub';
-import { addGlobalEventProcessor } from './scope';
 
 declare module '@sentry/types' {
   interface Integration {
@@ -107,10 +107,20 @@ export function setupIntegration(client: Client, integration: Integration, integ
   }
 
   if (client.on && typeof integration.preprocessEvent === 'function') {
-    const callback = integration.preprocessEvent.bind(integration);
+    const callback = integration.preprocessEvent.bind(integration) as typeof integration.preprocessEvent;
     client.on('preprocessEvent', (event, hint) => callback(event, hint, client));
   }
 
+  if (client.addEventProcessor && typeof integration.processEvent === 'function') {
+    const callback = integration.processEvent.bind(integration) as typeof integration.processEvent;
+
+    const processor = Object.assign((event: Event, hint: EventHint) => callback(event, hint, client), {
+      id: integration.name,
+    });
+
+    client.addEventProcessor(processor);
+  }
+
   __DEBUG_BUILD__ && logger.log(`Integration installed: ${integration.name}`);
 }
 

packages/core/src/scope.ts

@@ -22,17 +22,9 @@ import type {
   Transaction,
   User,
 } from '@sentry/types';
-import {
-  arrayify,
-  dateTimestampInSeconds,
-  getGlobalSingleton,
-  isPlainObject,
-  isThenable,
-  logger,
-  SyncPromise,
-  uuid4,
-} from '@sentry/utils';
+import { arrayify, dateTimestampInSeconds, isPlainObject, uuid4 } from '@sentry/utils';
 
+import { getGlobalEventProcessors, notifyEventProcessors } from './eventProcessors';
 import { updateSession } from './session';
 
 /**
@@ -525,7 +517,7 @@ export class Scope implements ScopeInterface {
       propagationContext: this._propagationContext,
     };
 
-    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);
+    return notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);
   }
 
   /**
@@ -559,40 +551,6 @@ export class Scope implements ScopeInterface {
     return this._breadcrumbs;
   }
 
-  /**
-   * This will be called after {@link applyToEvent} is finished.
-   */
-  protected _notifyEventProcessors(
-    processors: EventProcessor[],
-    event: Event | null,
-    hint: EventHint,
-    index: number = 0,
-  ): PromiseLike<Event | null> {
-    return new SyncPromise<Event | null>((resolve, reject) => {
-      const processor = processors[index];
-      if (event === null || typeof processor !== 'function') {
-        resolve(event);
-      } else {
-        const result = processor({ ...event }, hint) as Event | null;
-
-        __DEBUG_BUILD__ &&
-          processor.id &&
-          result === null &&
-          logger.log(`Event processor "${processor.id}" dropped event`);
-
-        if (isThenable(result)) {
-          void result
-            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))
-            .then(null, reject);
-        } else {
-          void this._notifyEventProcessors(processors, result, hint, index + 1)
-            .then(resolve)
-            .then(null, reject);
-        }
-      }
-    });
-  }
-
   /**
    * This will be called on every set call.
    */
@@ -629,21 +587,6 @@ export class Scope implements ScopeInterface {
   }
 }
 
-/**
- * Returns the global event processors.
- */
-function getGlobalEventProcessors(): EventProcessor[] {
-  return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);
-}
-
-/**
- * Add a EventProcessor to be kept globally.
- * @param callback EventProcessor to add
- */
-export function addGlobalEventProcessor(callback: EventProcessor): void {
-  getGlobalEventProcessors().push(callback);
-}
-
 function generatePropagationContext(): PropagationContext {
   return {
     traceId: uuid4(),

packages/core/src/utils/prepareEvent.ts

@@ -1,7 +1,8 @@
-import type { ClientOptions, Event, EventHint, StackFrame, StackParser } from '@sentry/types';
+import type { Client, ClientOptions, Event, EventHint, StackFrame, StackParser } from '@sentry/types';
 import { dateTimestampInSeconds, GLOBAL_OBJ, normalize, resolvedSyncPromise, truncate, uuid4 } from '@sentry/utils';
 
 import { DEFAULT_ENVIRONMENT } from '../constants';
+import { notifyEventProcessors } from '../eventProcessors';
 import { Scope } from '../scope';
 
 /**
@@ -26,6 +27,7 @@ export function prepareEvent(
   event: Event,
   hint: EventHint,
   scope?: Scope,
+  client?: Client,
 ): PromiseLike<Event | null> {
   const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = options;
   const prepared: Event = {
@@ -74,20 +76,25 @@ export function prepareEvent(
     result = finalScope.applyToEvent(prepared, hint);
   }
 
-  return result.then(evt => {
-    if (evt) {
-      // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified
-      // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.
-      // This should not cause any PII issues, since we're only moving data that is already on the event and not adding
-      // any new data
-      applyDebugMeta(evt);
-    }
+  return result
+    .then(evt => {
+      // Process client-scoped event processors
+      return client && client.getEventProcessors ? notifyEventProcessors(client.getEventProcessors(), evt, hint) : evt;
+    })
+    .then(evt => {
+      if (evt) {
+        // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified
+        // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.
+        // This should not cause any PII issues, since we're only moving data that is already on the event and not adding
+        // any new data
+        applyDebugMeta(evt);
+      }
 
-    if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
-      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
-    }
-    return evt;
-  });
+      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
+        return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
+      }
+      return evt;
+    });
 }
 
 /**