Update to Sentry v8 SDKs (robertcepa#234)

* Update to Sentry v8 SDKs

* Update to v8.0.0 stable

* Update to v8.3.0

* Update Sentry SDKs to v8.9.2

Author: timfish

packages/toucan-js/package.json

@@ -29,10 +29,9 @@
     "serverless"
   ],
   "dependencies": {
-    "@sentry/core": "7.112.2",
-    "@sentry/utils": "7.112.2",
-    "@sentry/types": "7.112.2",
-    "@sentry/integrations": "7.112.2"
+    "@sentry/core": "8.9.2",
+    "@sentry/utils": "8.9.2",
+    "@sentry/types": "8.9.2"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "25.0.3",

packages/toucan-js/src/client.ts

@@ -13,12 +13,14 @@ import { setOnOptional } from './utils';
  */
 export class ToucanClient extends ServerRuntimeClient<ToucanClientOptions> {
   /**
-   * Some functions need to access the Hub (Toucan instance) this client is bound to,
+   * Some functions need to access the scope (Toucan instance) this client is bound to,
    * but calling 'getCurrentHub()' is unsafe because it uses globals.
    * So we store a reference to the Hub after binding to it and provide it to methods that need it.
    */
   #sdk: Toucan | null = null;
 
+  #integrationsInitialized: boolean = false;
+
   /**
    * Creates a new Toucan SDK instance.
    * @param options Configuration options for this SDK.
@@ -43,12 +45,12 @@ export class ToucanClient extends ServerRuntimeClient<ToucanClientOptions> {
    * By default, integrations are stored in a global. We want to store them in a local instance because they may have contextual data, such as event request.
    */
   public setupIntegrations(): void {
-    if (this._isEnabled() && !this._integrationsInitialized && this.#sdk) {
+    if (this._isEnabled() && !this.#integrationsInitialized && this.#sdk) {
       this._integrations = setupIntegrations(
         this._options.integrations,
         this.#sdk,
       );
-      this._integrationsInitialized = true;
+      this.#integrationsInitialized = true;
     }
   }
 

packages/toucan-js/src/eventBuilder.ts

@@ -98,12 +98,10 @@ export function eventFromUnknownInput(
 
       const client = sdk?.getClient();
       const normalizeDepth = client && client.getOptions().normalizeDepth;
-      sdk?.configureScope((scope) => {
-        scope.setExtra(
-          '__serialized__',
-          normalizeToSize(exception, normalizeDepth),
-        );
-      });
+      sdk?.setExtra(
+        '__serialized__',
+        normalizeToSize(exception, normalizeDepth),
+      );
 
       ex = (hint && hint.syntheticException) || new Error(message);
       ex.message = message;

packages/toucan-js/src/index.ts

@@ -1,11 +1,10 @@
 export {
-  LinkedErrors,
-  RequestData,
-  Dedupe,
-  ExtraErrorData,
-  RewriteFrames,
-  SessionTiming,
-  Transaction,
+  linkedErrorsIntegration,
+  requestDataIntegration,
+  dedupeIntegration,
+  extraErrorDataIntegration,
+  rewriteFramesIntegration,
+  sessionTimingIntegration,
 } from './integrations';
 export type { LinkedErrorsOptions, RequestDataOptions } from './integrations';
 export { Toucan } from './sdk';

packages/toucan-js/src/integration.ts

@@ -1,5 +1,5 @@
 import { IntegrationIndex } from '@sentry/core/types/integration';
-import type { EventProcessor, Integration } from '@sentry/types';
+import type { EventHint, Event, Integration } from '@sentry/types';
 import type { Toucan } from './sdk';
 
 /**
@@ -16,12 +16,41 @@ export function setupIntegrations(
   integrations.forEach((integration) => {
     integrationIndex[integration.name] = integration;
 
-    integration.setupOnce(
-      (callback: EventProcessor): void => {
-        sdk.getScope()?.addEventProcessor(callback);
-      },
-      () => sdk,
-    );
+    // `setupOnce` is only called the first time
+    if (typeof integration.setupOnce === 'function') {
+      integration.setupOnce();
+    }
+
+    const client = sdk.getClient();
+
+    if (!client) {
+      return;
+    }
+
+    // `setup` is run for each client
+    if (typeof integration.setup === 'function') {
+      integration.setup(client);
+    }
+
+    if (typeof integration.preprocessEvent === 'function') {
+      const callback = integration.preprocessEvent.bind(integration);
+      client.on('preprocessEvent', (event, hint) =>
+        callback(event, hint, client),
+      );
+    }
+
+    if (typeof integration.processEvent === 'function') {
+      const callback = integration.processEvent.bind(integration);
+
+      const processor = Object.assign(
+        (event: Event, hint: EventHint) => callback(event, hint, client),
+        {
+          id: integration.name,
+        },
+      );
+
+      client.addEventProcessor(processor);
+    }
   });
 
   return integrationIndex;

packages/toucan-js/src/integrations/index.ts

@@ -1,9 +1,8 @@
 export * from './linkedErrors';
 export * from './requestData';
 export {
-  Dedupe,
-  ExtraErrorData,
-  RewriteFrames,
-  SessionTiming,
-  Transaction,
-} from '@sentry/integrations';
+  dedupeIntegration,
+  extraErrorDataIntegration,
+  rewriteFramesIntegration,
+  sessionTimingIntegration,
+} from '@sentry/core';

packages/toucan-js/src/integrations/linkedErrors.ts

@@ -1,56 +1,36 @@
 import {
   Event,
   EventHint,
-  EventProcessor,
   Exception,
   ExtendedError,
-  Integration,
   StackParser,
 } from '@sentry/types';
 import { isInstanceOf } from '@sentry/utils';
+import { defineIntegration } from '@sentry/core';
 
-import { ToucanClient } from '../client';
 import { exceptionFromError } from '../eventBuilder';
-import { Toucan } from '../sdk';
 
 const DEFAULT_LIMIT = 5;
 
 export type LinkedErrorsOptions = {
   limit: number;
 };
 
-export class LinkedErrors implements Integration {
-  public static id = 'LinkedErrors';
-
-  public readonly name: string = LinkedErrors.id;
-
-  private readonly limit: LinkedErrorsOptions['limit'];
-
-  public constructor(options: Partial<LinkedErrorsOptions> = {}) {
-    this.limit = options.limit || DEFAULT_LIMIT;
-  }
-
-  public setupOnce(
-    addGlobalEventProcessor: (eventProcessor: EventProcessor) => void,
-    getCurrentHub: () => Toucan,
-  ): void {
-    const client = getCurrentHub().getClient<ToucanClient>();
-
-    if (!client) {
-      return;
-    }
-
-    addGlobalEventProcessor((event: Event, hint?: EventHint) => {
-      const self = getCurrentHub().getIntegration(LinkedErrors);
-
-      if (!self) {
-        return event;
-      }
-
-      return handler(client.getOptions().stackParser, self.limit, event, hint);
-    });
-  }
-}
+export const linkedErrorsIntegration = defineIntegration(
+  (options: LinkedErrorsOptions = { limit: DEFAULT_LIMIT }) => {
+    return {
+      name: 'LinkedErrors',
+      processEvent: (event, hint, client) => {
+        return handler(
+          client.getOptions().stackParser,
+          options.limit,
+          event,
+          hint,
+        );
+      },
+    };
+  },
+);
 
 function handler(
   parser: StackParser,

packages/toucan-js/src/integrations/requestData.ts

@@ -1,8 +1,6 @@
-import { Event, EventProcessor, Integration, User } from '@sentry/types';
-
+import { User } from '@sentry/types';
+import { defineIntegration } from '@sentry/core';
 import type { Request as EventRequest } from '@sentry/types';
-import { ToucanClient } from '../client';
-import { Toucan } from '../sdk';
 
 type Allowlist = string[] | RegExp | boolean;
 
@@ -17,65 +15,49 @@ const defaultRequestDataOptions: RequestDataOptions = {
   allowedHeaders: ['CF-RAY', 'CF-Worker'],
 };
 
-export class RequestData implements Integration {
-  public static id = 'RequestData';
-
-  public readonly name: string = RequestData.id;
-
-  #options: RequestDataOptions;
-
-  public constructor(options: RequestDataOptions = {}) {
-    this.#options = { ...defaultRequestDataOptions, ...options };
-  }
-
-  public setupOnce(
-    addGlobalEventProcessor: (eventProcessor: EventProcessor) => void,
-    getCurrentHub: () => Toucan,
-  ): void {
-    const client = getCurrentHub().getClient<ToucanClient>();
+export const requestDataIntegration = defineIntegration(
+  (userOptions: RequestDataOptions = {}) => {
+    const options = { ...defaultRequestDataOptions, ...userOptions };
 
-    if (!client) {
-      return;
-    }
+    return {
+      name: 'RequestData',
+      preprocessEvent: (event) => {
+        const { sdkProcessingMetadata } = event;
 
-    addGlobalEventProcessor((event: Event) => {
-      const { sdkProcessingMetadata } = event;
+        if (!sdkProcessingMetadata) {
+          return event;
+        }
 
-      const self = getCurrentHub().getIntegration(RequestData);
+        if (
+          'request' in sdkProcessingMetadata &&
+          sdkProcessingMetadata.request instanceof Request
+        ) {
+          event.request = toEventRequest(
+            sdkProcessingMetadata.request,
+            options,
+          );
+          event.user = toEventUser(
+            event.user ?? {},
+            sdkProcessingMetadata.request,
+            options,
+          );
+        }
 
-      if (!self || !sdkProcessingMetadata) {
-        return event;
-      }
-
-      if (
-        'request' in sdkProcessingMetadata &&
-        sdkProcessingMetadata.request instanceof Request
-      ) {
-        event.request = toEventRequest(
-          sdkProcessingMetadata.request,
-          this.#options,
-        );
-        event.user = toEventUser(
-          event.user ?? {},
-          sdkProcessingMetadata.request,
-          this.#options,
-        );
-      }
-
-      if ('requestData' in sdkProcessingMetadata) {
-        if (event.request) {
-          event.request.data = sdkProcessingMetadata.requestData as unknown;
-        } else {
-          event.request = {
-            data: sdkProcessingMetadata.requestData as unknown,
-          };
+        if ('requestData' in sdkProcessingMetadata) {
+          if (event.request) {
+            event.request.data = sdkProcessingMetadata.requestData as unknown;
+          } else {
+            event.request = {
+              data: sdkProcessingMetadata.requestData as unknown,
+            };
+          }
         }
-      }
 
-      return event;
-    });
-  }
-}
+        return event;
+      },
+    };
+  },
+);
 
 /**
  * Applies allowlists on existing user object.