fix: Ensure all integration classes have correct types (#10183)

This ensures that all integration classes have both the correct
constructor options, as well as the correct instance methods.

This is pretty dirty, but since we're going to remove the classes very
soon in v8, IMHO that's the easiest approach to make this work properly
for our users.

Somehow TS complains when using the option types directly, so we inline
them for now everywhere, which seems to make it happy. 🤷 soon we'll
remove these anyhow!

Extracted out of
#10143

Author: mydea

packages/browser/src/integrations/breadcrumbs.ts

@@ -8,6 +8,8 @@ import type {
   HandlerDataFetch,
   HandlerDataHistory,
   HandlerDataXhr,
+  Integration,
+  IntegrationClass,
   IntegrationFn,
 } from '@sentry/types';
 import type {
@@ -55,7 +57,7 @@ const MAX_ALLOWED_STRING_LENGTH = 1024;
 
 const INTEGRATION_NAME = 'Breadcrumbs';
 
-const breadcrumbsIntegration: IntegrationFn = (options: Partial<BreadcrumbsOptions> = {}) => {
+const breadcrumbsIntegration = ((options: Partial<BreadcrumbsOptions> = {}) => {
   const _options = {
     console: true,
     dom: true,
@@ -91,13 +93,31 @@ const breadcrumbsIntegration: IntegrationFn = (options: Partial<BreadcrumbsOptio
       }
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /**
  * Default Breadcrumbs instrumentations
  */
 // eslint-disable-next-line deprecation/deprecation
-export const Breadcrumbs = convertIntegrationFnToClass(INTEGRATION_NAME, breadcrumbsIntegration);
+export const Breadcrumbs = convertIntegrationFnToClass(INTEGRATION_NAME, breadcrumbsIntegration) as IntegrationClass<
+  Integration & { setup: (client: Client) => void }
+> & {
+  new (
+    options?: Partial<{
+      console: boolean;
+      dom:
+        | boolean
+        | {
+            serializeAttribute?: string | string[];
+            maxStringLength?: number;
+          };
+      fetch: boolean;
+      history: boolean;
+      sentry: boolean;
+      xhr: boolean;
+    }>,
+  ): Integration;
+};
 
 /**
  * Adds a breadcrumb for Sentry events or transactions if this option is enabled.

packages/browser/src/integrations/dedupe.ts

@@ -1,12 +1,12 @@
 import { convertIntegrationFnToClass } from '@sentry/core';
-import type { Event, Exception, IntegrationFn, StackFrame } from '@sentry/types';
+import type { Event, Exception, Integration, IntegrationClass, IntegrationFn, StackFrame } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 
 const INTEGRATION_NAME = 'Dedupe';
 
-const dedupeIntegration: IntegrationFn = () => {
+const dedupeIntegration = (() => {
   let previousEvent: Event | undefined;
 
   return {
@@ -31,11 +31,13 @@ const dedupeIntegration: IntegrationFn = () => {
       return (previousEvent = currentEvent);
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /** Deduplication filter */
 // eslint-disable-next-line deprecation/deprecation
-export const Dedupe = convertIntegrationFnToClass(INTEGRATION_NAME, dedupeIntegration);
+export const Dedupe = convertIntegrationFnToClass(INTEGRATION_NAME, dedupeIntegration) as IntegrationClass<
+  Integration & { processEvent: (event: Event) => Event }
+>;
 
 function _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
   if (!previousEvent) {

packages/browser/src/integrations/globalhandlers.ts

@@ -1,6 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { captureEvent, convertIntegrationFnToClass, getClient } from '@sentry/core';
-import type { Client, Event, IntegrationFn, Primitive, StackParser } from '@sentry/types';
+import type {
+  Client,
+  Event,
+  Integration,
+  IntegrationClass,
+  IntegrationFn,
+  Primitive,
+  StackParser,
+} from '@sentry/types';
 import {
   addGlobalErrorInstrumentationHandler,
   addGlobalUnhandledRejectionInstrumentationHandler,
@@ -22,7 +30,7 @@ type GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, b
 
 const INTEGRATION_NAME = 'GlobalHandlers';
 
-const globalHandlersIntegrations: IntegrationFn = (options: Partial<GlobalHandlersIntegrations> = {}) => {
+const globalHandlersIntegration = ((options: Partial<GlobalHandlersIntegrations> = {}) => {
   const _options = {
     onerror: true,
     onunhandledrejection: true,
@@ -45,11 +53,16 @@ const globalHandlersIntegrations: IntegrationFn = (options: Partial<GlobalHandle
       }
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /** Global handlers */
 // eslint-disable-next-line deprecation/deprecation
-export const GlobalHandlers = convertIntegrationFnToClass(INTEGRATION_NAME, globalHandlersIntegrations);
+export const GlobalHandlers = convertIntegrationFnToClass(
+  INTEGRATION_NAME,
+  globalHandlersIntegration,
+) as IntegrationClass<Integration & { setup: (client: Client) => void }> & {
+  new (options?: Partial<GlobalHandlersIntegrations>): Integration;
+};
 
 function _installGlobalOnErrorHandler(client: Client): void {
   addGlobalErrorInstrumentationHandler(data => {

packages/browser/src/integrations/httpcontext.ts

@@ -1,11 +1,11 @@
 import { convertIntegrationFnToClass } from '@sentry/core';
-import type { IntegrationFn } from '@sentry/types';
+import type { Event, Integration, IntegrationClass, IntegrationFn } from '@sentry/types';
 
 import { WINDOW } from '../helpers';
 
 const INTEGRATION_NAME = 'HttpContext';
 
-const httpContextIntegration: IntegrationFn = () => {
+const httpContextIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
     // TODO v8: Remove this
@@ -31,8 +31,10 @@ const httpContextIntegration: IntegrationFn = () => {
       event.request = request;
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /** HttpContext integration collects information about HTTP request headers */
 // eslint-disable-next-line deprecation/deprecation
-export const HttpContext = convertIntegrationFnToClass(INTEGRATION_NAME, httpContextIntegration);
+export const HttpContext = convertIntegrationFnToClass(INTEGRATION_NAME, httpContextIntegration) as IntegrationClass<
+  Integration & { preprocessEvent: (event: Event) => void }
+>;

packages/browser/src/integrations/linkederrors.ts

@@ -1,5 +1,5 @@
 import { convertIntegrationFnToClass } from '@sentry/core';
-import type { IntegrationFn } from '@sentry/types';
+import type { Client, Event, EventHint, Integration, IntegrationClass, IntegrationFn } from '@sentry/types';
 import { applyAggregateErrorsToEvent } from '@sentry/utils';
 import { exceptionFromError } from '../eventbuilder';
 
@@ -13,7 +13,7 @@ const DEFAULT_LIMIT = 5;
 
 const INTEGRATION_NAME = 'LinkedErrors';
 
-const linkedErrorsIntegration: IntegrationFn = (options: LinkedErrorsOptions = {}) => {
+const linkedErrorsIntegration = ((options: LinkedErrorsOptions = {}) => {
   const limit = options.limit || DEFAULT_LIMIT;
   const key = options.key || DEFAULT_KEY;
 
@@ -36,8 +36,10 @@ const linkedErrorsIntegration: IntegrationFn = (options: LinkedErrorsOptions = {
       );
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /** Aggregrate linked errors in an event. */
 // eslint-disable-next-line deprecation/deprecation
-export const LinkedErrors = convertIntegrationFnToClass(INTEGRATION_NAME, linkedErrorsIntegration);
+export const LinkedErrors = convertIntegrationFnToClass(INTEGRATION_NAME, linkedErrorsIntegration) as IntegrationClass<
+  Integration & { preprocessEvent: (event: Event, hint: EventHint, client: Client) => void }
+> & { new (options?: { key?: string; limit?: number }): Integration };

packages/browser/src/integrations/trycatch.ts

@@ -1,5 +1,5 @@
 import { convertIntegrationFnToClass } from '@sentry/core';
-import type { IntegrationFn, WrappedFunction } from '@sentry/types';
+import type { Integration, IntegrationClass, IntegrationFn, WrappedFunction } from '@sentry/types';
 import { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';
 
 import { WINDOW, wrap } from '../helpers';
@@ -50,7 +50,7 @@ interface TryCatchOptions {
   eventTarget: boolean | string[];
 }
 
-const tryCatchIntegration: IntegrationFn = (options: Partial<TryCatchOptions> = {}) => {
+const browserApiErrorsIntegration = ((options: Partial<TryCatchOptions> = {}) => {
   const _options = {
     XMLHttpRequest: true,
     eventTarget: true,
@@ -88,11 +88,22 @@ const tryCatchIntegration: IntegrationFn = (options: Partial<TryCatchOptions> =
       }
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /** Wrap timer functions and event targets to catch errors and provide better meta data */
 // eslint-disable-next-line deprecation/deprecation
-export const TryCatch = convertIntegrationFnToClass(INTEGRATION_NAME, tryCatchIntegration);
+export const TryCatch = convertIntegrationFnToClass(
+  INTEGRATION_NAME,
+  browserApiErrorsIntegration,
+) as IntegrationClass<Integration> & {
+  new (options?: {
+    setTimeout: boolean;
+    setInterval: boolean;
+    requestAnimationFrame: boolean;
+    XMLHttpRequest: boolean;
+    eventTarget: boolean | string[];
+  }): Integration;
+};
 
 function _wrapTimeFunction(original: () => void): () => number {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

packages/browser/src/profiling/integration.ts

@@ -1,5 +1,5 @@
 import { convertIntegrationFnToClass, getCurrentScope } from '@sentry/core';
-import type { EventEnvelope, IntegrationFn, Transaction } from '@sentry/types';
+import type { Client, EventEnvelope, Integration, IntegrationClass, IntegrationFn, Transaction } from '@sentry/types';
 import type { Profile } from '@sentry/types/src/profiling';
 import { logger } from '@sentry/utils';
 
@@ -18,7 +18,7 @@ import {
 
 const INTEGRATION_NAME = 'BrowserProfiling';
 
-const browserProfilingIntegration: IntegrationFn = () => {
+const browserProfilingIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
     // TODO v8: Remove this
@@ -100,7 +100,7 @@ const browserProfilingIntegration: IntegrationFn = () => {
       });
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /**
  * Browser profiling integration. Stores any event that has contexts["profile"]["profile_id"]
@@ -112,4 +112,7 @@ const browserProfilingIntegration: IntegrationFn = () => {
  * @experimental
  */
 // eslint-disable-next-line deprecation/deprecation
-export const BrowserProfilingIntegration = convertIntegrationFnToClass(INTEGRATION_NAME, browserProfilingIntegration);
+export const BrowserProfilingIntegration = convertIntegrationFnToClass(
+  INTEGRATION_NAME,
+  browserProfilingIntegration,
+) as IntegrationClass<Integration & { setup: (client: Client) => void }>;

packages/browser/test/unit/profiling/integration.test.ts

@@ -36,7 +36,6 @@ describe('BrowserProfilingIntegration', () => {
     Sentry.init({
       tracesSampleRate: 1,
       profilesSampleRate: 1,
-      debug: true,
       environment: 'test-environment',
       dsn: 'https://[email protected]/6625302',
       transport: _opts => {

packages/bun/src/integrations/bunserver.ts

@@ -13,14 +13,14 @@ import { getSanitizedUrlString, parseUrl } from '@sentry/utils';
 
 const INTEGRATION_NAME = 'BunServer';
 
-const bunServerIntegration: IntegrationFn = () => {
+const bunServerIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
       instrumentBunServe();
     },
   };
-};
+}) satisfies IntegrationFn;
 
 /**
  * Instruments `Bun.serve` to automatically create transactions and capture errors.

packages/core/src/integration.ts

@@ -1,4 +1,4 @@
-import type { Client, Event, EventHint, Integration, IntegrationFn, Options } from '@sentry/types';
+import type { Client, Event, EventHint, Integration, IntegrationClass, IntegrationFn, Options } from '@sentry/types';
 import { arrayify, logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from './debug-build';
@@ -169,18 +169,11 @@ function findIndex<T>(arr: T[], callback: (item: T) => boolean): number {
 export function convertIntegrationFnToClass<Fn extends IntegrationFn>(
   name: string,
   fn: Fn,
-): Integration & {
-  id: string;
-  new (...args: Parameters<Fn>): Integration & ReturnType<Fn>;
-} {
+): IntegrationClass<Integration> {
   return Object.assign(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function ConvertedIntegration(...rest: Parameters<Fn>) {
-      return fn(...rest);
+    function ConvertedIntegration(...args: Parameters<Fn>): Integration {
+      return fn(...args);
     },
     { id: name },
-  ) as unknown as Integration & {
-    id: string;
-    new (...args: Parameters<Fn>): Integration & ReturnType<Fn>;
-  };
+  ) as unknown as IntegrationClass<Integration>;
 }