ref(integrations): Rewrite pluggable integrations to use functional style

Author: mydea

packages/core/src/integration.ts

@@ -176,9 +176,10 @@ export function convertIntegrationFnToClass<Fn extends IntegrationFn>(
   name: string,
   fn: Fn,
 ): IntegrationClass<
-  Integration & {
-    setupOnce: (addGlobalEventProcessor?: (callback: EventProcessor) => void, getCurrentHub?: () => Hub) => void;
-  }
+  Integration &
+    ReturnType<Fn> & {
+      setupOnce: (addGlobalEventProcessor?: (callback: EventProcessor) => void, getCurrentHub?: () => Hub) => void;
+    }
 > {
   return Object.assign(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -191,8 +192,9 @@ export function convertIntegrationFnToClass<Fn extends IntegrationFn>(
     },
     { id: name },
   ) as unknown as IntegrationClass<
-    Integration & {
-      setupOnce: (addGlobalEventProcessor?: (callback: EventProcessor) => void, getCurrentHub?: () => Hub) => void;
-    }
+    Integration &
+      ReturnType<Fn> & {
+        setupOnce: (addGlobalEventProcessor?: (callback: EventProcessor) => void, getCurrentHub?: () => Hub) => void;
+      }
   >;
 }

packages/integrations/src/captureconsole.ts

@@ -1,5 +1,5 @@
-import { captureException, captureMessage, getClient, withScope } from '@sentry/core';
-import type { CaptureContext, Client, EventProcessor, Hub, Integration } from '@sentry/types';
+import { captureException, captureMessage, convertIntegrationFnToClass, getClient, withScope } from '@sentry/core';
+import type { CaptureContext, IntegrationFn } from '@sentry/types';
 import {
   CONSOLE_LEVELS,
   GLOBAL_OBJ,
@@ -9,55 +9,36 @@ import {
   severityLevelFromString,
 } from '@sentry/utils';
 
-/** Send Console API calls as Sentry Events */
-export class CaptureConsole implements Integration {
-  /**
-   * @inheritDoc
-   */
-  public static id: string = 'CaptureConsole';
-
-  /**
-   * @inheritDoc
-   */
-  public name: string;
-
-  /**
-   * @inheritDoc
-   */
-  private readonly _levels: readonly string[];
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(options: { levels?: string[] } = {}) {
-    this.name = CaptureConsole.id;
-    this._levels = options.levels || CONSOLE_LEVELS;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public setupOnce(_: (callback: EventProcessor) => void, _getCurrentHub: () => Hub): void {
-    // noop
-  }
+interface CaptureConsoleOptions {
+  levels?: string[];
+}
 
-  /** @inheritdoc */
-  public setup(client: Client): void {
-    if (!('console' in GLOBAL_OBJ)) {
-      return;
-    }
+const INTEGRATION_NAME = 'CaptureConsole';
 
-    const levels = this._levels;
+const captureConsoleIntegration = ((options: CaptureConsoleOptions = {}) => {
+  const levels = options.levels || CONSOLE_LEVELS;
 
-    addConsoleInstrumentationHandler(({ args, level }) => {
-      if (getClient() !== client || !levels.includes(level)) {
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      if (!('console' in GLOBAL_OBJ)) {
         return;
       }
 
-      consoleHandler(args, level);
-    });
-  }
-}
+      addConsoleInstrumentationHandler(({ args, level }) => {
+        if (getClient() !== client || !levels.includes(level)) {
+          return;
+        }
+
+        consoleHandler(args, level);
+      });
+    },
+  };
+}) satisfies IntegrationFn;
+
+/** Send Console API calls as Sentry Events */
+// eslint-disable-next-line deprecation/deprecation
+export const CaptureConsole = convertIntegrationFnToClass(INTEGRATION_NAME, captureConsoleIntegration);
 
 function consoleHandler(args: unknown[], level: string): void {
   const captureContext: CaptureContext = {

packages/integrations/src/contextlines.ts

@@ -1,10 +1,13 @@
-import type { Event, Integration, StackFrame } from '@sentry/types';
+import { convertIntegrationFnToClass } from '@sentry/core';
+import type { Event, IntegrationFn, StackFrame } from '@sentry/types';
 import { GLOBAL_OBJ, addContextToFrame, stripUrlQueryAndFragment } from '@sentry/utils';
 
 const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;
 
 const DEFAULT_LINES_OF_CONTEXT = 7;
 
+const INTEGRATION_NAME = 'ContextLines';
+
 interface ContextLinesOptions {
   /**
    * Sets the number of context lines for each frame when loading a file.
@@ -15,6 +18,17 @@ interface ContextLinesOptions {
   frameContextLines?: number;
 }
 
+const contextLinesIntegration: IntegrationFn = (options: ContextLinesOptions = {}) => {
+  const contextLines = options.frameContextLines != null ? options.frameContextLines : DEFAULT_LINES_OF_CONTEXT;
+
+  return {
+    name: INTEGRATION_NAME,
+    processEvent(event) {
+      return addSourceContext(event, contextLines);
+    },
+  };
+};
+
 /**
  * Collects source context lines around the lines of stackframes pointing to JS embedded in
  * the current page's HTML.
@@ -26,73 +40,41 @@ interface ContextLinesOptions {
  * Use this integration if you have inline JS code in HTML pages that can't be accessed
  * by our backend (e.g. due to a login-protected page).
  */
-export class ContextLines implements Integration {
-  /**
-   * @inheritDoc
-   */
-  public static id: string = 'ContextLines';
-
-  /**
-   * @inheritDoc
-   */
-  public name: string;
+// eslint-disable-next-line deprecation/deprecation
+export const ContextLines = convertIntegrationFnToClass(INTEGRATION_NAME, contextLinesIntegration);
 
-  public constructor(private readonly _options: ContextLinesOptions = {}) {
-    this.name = ContextLines.id;
+/**
+ * Processes an event and adds context lines.
+ */
+function addSourceContext(event: Event, contextLines: number): Event {
+  const doc = WINDOW.document;
+  const htmlFilename = WINDOW.location && stripUrlQueryAndFragment(WINDOW.location.href);
+  if (!doc || !htmlFilename) {
+    return event;
   }
 
-  /**
-   * @inheritDoc
-   */
-  public setupOnce(_addGlobalEventProcessor: unknown, _getCurrentHub: unknown): void {
-    // noop
+  const exceptions = event.exception && event.exception.values;
+  if (!exceptions || !exceptions.length) {
+    return event;
   }
 
-  /** @inheritDoc */
-  public processEvent(event: Event): Event {
-    return this.addSourceContext(event);
+  const html = doc.documentElement.innerHTML;
+  if (!html) {
+    return event;
   }
 
-  /**
-   * Processes an event and adds context lines.
-   *
-   * TODO (v8): Make this internal/private
-   */
-  public addSourceContext(event: Event): Event {
-    const doc = WINDOW.document;
-    const htmlFilename = WINDOW.location && stripUrlQueryAndFragment(WINDOW.location.href);
-    if (!doc || !htmlFilename) {
-      return event;
-    }
-
-    const exceptions = event.exception && event.exception.values;
-    if (!exceptions || !exceptions.length) {
-      return event;
-    }
+  const htmlLines = ['<!DOCTYPE html>', '<html>', ...html.split('\n'), '</html>'];
 
-    const html = doc.documentElement.innerHTML;
-    if (!html) {
-      return event;
+  exceptions.forEach(exception => {
+    const stacktrace = exception.stacktrace;
+    if (stacktrace && stacktrace.frames) {
+      stacktrace.frames = stacktrace.frames.map(frame =>
+        applySourceContextToFrame(frame, htmlLines, htmlFilename, contextLines),
+      );
     }
+  });
 
-    const htmlLines = ['<!DOCTYPE html>', '<html>', ...html.split('\n'), '</html>'];
-
-    exceptions.forEach(exception => {
-      const stacktrace = exception.stacktrace;
-      if (stacktrace && stacktrace.frames) {
-        stacktrace.frames = stacktrace.frames.map(frame =>
-          applySourceContextToFrame(
-            frame,
-            htmlLines,
-            htmlFilename,
-            this._options.frameContextLines != null ? this._options.frameContextLines : DEFAULT_LINES_OF_CONTEXT,
-          ),
-        );
-      }
-    });
-
-    return event;
-  }
+  return event;
 }
 
 /**

packages/integrations/src/debug.ts

@@ -1,77 +1,59 @@
-import type { Client, Event, EventHint, EventProcessor, Hub, Integration } from '@sentry/types';
+import { convertIntegrationFnToClass } from '@sentry/core';
+import type { Event, EventHint, IntegrationFn } from '@sentry/types';
 import { consoleSandbox } from '@sentry/utils';
 
+const INTEGRATION_NAME = 'Debug';
+
 interface DebugOptions {
   /** Controls whether console output created by this integration should be stringified. Default: `false` */
   stringify?: boolean;
   /** Controls whether a debugger should be launched before an event is sent. Default: `false` */
   debugger?: boolean;
 }
 
-/**
- * Integration to debug sent Sentry events.
- * This integration should not be used in production
- */
-export class Debug implements Integration {
-  /**
-   * @inheritDoc
-   */
-  public static id: string = 'Debug';
-
-  /**
-   * @inheritDoc
-   */
-  public name: string;
-
-  private readonly _options: DebugOptions;
-
-  public constructor(options?: DebugOptions) {
-    this.name = Debug.id;
-
-    this._options = {
-      debugger: false,
-      stringify: false,
-      ...options,
-    };
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public setupOnce(
-    _addGlobalEventProcessor: (eventProcessor: EventProcessor) => void,
-    _getCurrentHub: () => Hub,
-  ): void {
-    // noop
-  }
-
-  /** @inheritdoc */
-  public setup(client: Client): void {
-    if (!client.on) {
-      return;
-    }
-
-    client.on('beforeSendEvent', (event: Event, hint?: EventHint) => {
-      if (this._options.debugger) {
-        // eslint-disable-next-line no-debugger
-        debugger;
+const debugIntegration = ((options: DebugOptions = {}) => {
+  const _options = {
+    debugger: false,
+    stringify: false,
+    ...options,
+  };
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      if (!client.on) {
+        return;
       }
 
-      /* eslint-disable no-console */
-      consoleSandbox(() => {
-        if (this._options.stringify) {
-          console.log(JSON.stringify(event, null, 2));
-          if (hint && Object.keys(hint).length) {
-            console.log(JSON.stringify(hint, null, 2));
-          }
-        } else {
-          console.log(event);
-          if (hint && Object.keys(hint).length) {
-            console.log(hint);
-          }
+      client.on('beforeSendEvent', (event: Event, hint?: EventHint) => {
+        if (_options.debugger) {
+          // eslint-disable-next-line no-debugger
+          debugger;
         }
+
+        /* eslint-disable no-console */
+        consoleSandbox(() => {
+          if (_options.stringify) {
+            console.log(JSON.stringify(event, null, 2));
+            if (hint && Object.keys(hint).length) {
+              console.log(JSON.stringify(hint, null, 2));
+            }
+          } else {
+            console.log(event);
+            if (hint && Object.keys(hint).length) {
+              console.log(hint);
+            }
+          }
+        });
+        /* eslint-enable no-console */
       });
-      /* eslint-enable no-console */
-    });
-  }
-}
+    },
+  };
+}) satisfies IntegrationFn;
+
+/**
+ * Integration to debug sent Sentry events.
+ * This integration should not be used in production
+ */
+// eslint-disable-next-line deprecation/deprecation
+export const Debug = convertIntegrationFnToClass(INTEGRATION_NAME, debugIntegration);