feat: Avoid class fields alltogether

We already have an eslint rule to avoid class fields, but had exceptions for static fields as well as for arrow functions.

This also leads to bundle size increases, so removing the exceptions and handling the (few) exceptions we have there should save some bytes.

Additionally, this has additional challenges if we want to avoid/reduce polyfills, as class fields need to be polyfilled for ES2020, sadly.

Author: mydea

docs/migration/v8-to-v9.md

@@ -78,6 +78,8 @@ Sentry.init({
 
 In v9, an `undefined` value will be treated the same as if the value is not defined at all. You'll need to set `tracesSampleRate: 0` if you want to enable tracing without performance.
 
+- The `getCurrentHub().getIntegration(IntegrationClass)` method will always return `null` in v9. This has already stopped working mostly in v8, because we stopped exposing integration classes. In v9, the fallback behavior has been removed. Note that this does not change the type signature and is thus not technically breaking, but still worth pointing out.
+
 ### `@sentry/node`
 
 - When `skipOpenTelemetrySetup: true` is configured, `httpIntegration({ spans: false })` will be configured by default. This means that you no longer have to specify this yourself in this scenario. With this change, no spans are emitted once `skipOpenTelemetrySetup: true` is configured, without any further configuration being needed.
@@ -207,6 +209,7 @@ This led to some duplication, where we had to keep an interface in `@sentry/type
 Since v9, the types have been merged into `@sentry/core`, which removed some of this duplication. This means that certain things that used to be a separate interface, will not expect an actual instance of the class/concrete implementation. This should not affect most users, unless you relied on passing things with a similar shape to internal methods. The following types are affected:
 
 - `Scope` now always expects the `Scope` class
+- The `IntegrationClass` type is no longer exported - it was not used anymore. Instead, use `Integration` or `IntegrationFn`.
 
 # No Version Support Timeline
 

packages/angular/.eslintrc.cjs

@@ -4,4 +4,8 @@ module.exports = {
   },
   extends: ['../../.eslintrc.js'],
   ignorePatterns: ['setup-test.ts', 'patch-vitest.ts'],
+  rules: {
+    // Angular transpiles this correctly/relies on this
+    '@sentry-internal/sdk/no-class-field-initializers': 'off',
+  },
 };

packages/core/src/getCurrentHubShim.ts

@@ -11,7 +11,7 @@ import {
   setUser,
   startSession,
 } from './exports';
-import type { Client, EventHint, Hub, Integration, IntegrationClass, SeverityLevel } from './types-hoist';
+import type { Client, EventHint, Hub, Integration, SeverityLevel } from './types-hoist';
 
 /**
  * This is for legacy reasons, and returns a proxy object instead of a hub to be used.
@@ -48,9 +48,8 @@ export function getCurrentHubShim(): Hub {
     setExtras,
     setContext,
 
-    getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {
-      const client = getClient();
-      return (client && client.getIntegrationByName<T>(integration.id)) || null;
+    getIntegration<T extends Integration>(_integration: unknown): T | null {
+      return null;
     },
 
     startSession,

packages/core/src/types-hoist/hub.ts

@@ -3,7 +3,7 @@ import type { Breadcrumb, BreadcrumbHint } from './breadcrumb';
 import type { Client } from './client';
 import type { Event, EventHint } from './event';
 import type { Extra, Extras } from './extra';
-import type { Integration, IntegrationClass } from './integration';
+import type { Integration } from './integration';
 import type { Primitive } from './misc';
 import type { Session } from './session';
 import type { SeverityLevel } from './severity';
@@ -171,9 +171,9 @@ export interface Hub {
   /**
    * Returns the integration if installed on the current client.
    *
-   * @deprecated Use `Sentry.getClient().getIntegration()` instead.
+   * @deprecated Use `Sentry.getClient().getIntegrationByName()` instead.
    */
-  getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null;
+  getIntegration<T extends Integration>(integration: unknown): T | null;
 
   /**
    * Starts a new `Session`, sets on the current scope and returns it.

packages/core/src/types-hoist/index.ts

@@ -58,7 +58,7 @@ export type { Exception } from './exception';
 export type { Extra, Extras } from './extra';
 // eslint-disable-next-line deprecation/deprecation
 export type { Hub } from './hub';
-export type { Integration, IntegrationClass, IntegrationFn } from './integration';
+export type { Integration, IntegrationFn } from './integration';
 export type { Mechanism } from './mechanism';
 export type { ExtractedNodeRequestData, HttpHeaderValue, Primitive, WorkerLocation } from './misc';
 export type { ClientOptions, Options } from './options';

packages/core/src/types-hoist/integration.ts

@@ -1,16 +1,6 @@
 import type { Client } from './client';
 import type { Event, EventHint } from './event';
 
-/** Integration Class Interface */
-export interface IntegrationClass<T> {
-  /**
-   * Property that holds the integration name
-   */
-  id: string;
-
-  new (...args: any[]): T;
-}
-
 /** Integration interface */
 export interface Integration {
   /**

packages/core/src/utils-hoist/syncpromise.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { isThenable } from './is';
 
@@ -44,25 +43,78 @@ export function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {
  * Thenable class that behaves like a Promise and follows it's interface
  * but is not async internally
  */
-class SyncPromise<T> implements PromiseLike<T> {
+export class SyncPromise<T> implements PromiseLike<T> {
   private _state: States;
   private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]>;
   private _value: any;
+  private _resolve: (value?: T | PromiseLike<T> | null) => void;
+  private _reject: (reason?: any) => void;
+  private _executeHandlers: () => void;
+  private _setResult: (state: States, value?: T | PromiseLike<T> | any) => void;
 
   public constructor(
     executor: (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void,
   ) {
     this._state = States.PENDING;
     this._handlers = [];
 
+    this._resolve = (value?: T | PromiseLike<T> | null) => {
+      this._setResult(States.RESOLVED, value);
+    };
+
+    this._reject = (reason?: any) => {
+      this._setResult(States.REJECTED, reason);
+    };
+
+    this._executeHandlers = () => {
+      if (this._state === States.PENDING) {
+        return;
+      }
+
+      const cachedHandlers = this._handlers.slice();
+      this._handlers = [];
+
+      cachedHandlers.forEach(handler => {
+        if (handler[0]) {
+          return;
+        }
+
+        if (this._state === States.RESOLVED) {
+          handler[1](this._value as unknown as any);
+        }
+
+        if (this._state === States.REJECTED) {
+          handler[2](this._value);
+        }
+
+        handler[0] = true;
+      });
+    };
+
+    this._setResult = (state: States, value?: T | PromiseLike<T> | any) => {
+      if (this._state !== States.PENDING) {
+        return;
+      }
+
+      if (isThenable(value)) {
+        void (value as PromiseLike<T>).then(this._resolve, this._reject);
+        return;
+      }
+
+      this._state = state;
+      this._value = value;
+
+      this._executeHandlers();
+    };
+
     try {
       executor(this._resolve, this._reject);
     } catch (e) {
       this._reject(e);
     }
   }
 
-  /** JSDoc */
+  /** @inheritdoc */
   public then<TResult1 = T, TResult2 = never>(
     onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
@@ -99,14 +151,14 @@ class SyncPromise<T> implements PromiseLike<T> {
     });
   }
 
-  /** JSDoc */
+  /** @inheritdoc */
   public catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,
   ): PromiseLike<T | TResult> {
     return this.then(val => val, onrejected);
   }
 
-  /** JSDoc */
+  /** @inheritdoc */
   public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {
     return new SyncPromise<TResult>((resolve, reject) => {
       let val: TResult | any;
@@ -137,59 +189,4 @@ class SyncPromise<T> implements PromiseLike<T> {
       });
     });
   }
-
-  /** JSDoc */
-  private readonly _resolve = (value?: T | PromiseLike<T> | null) => {
-    this._setResult(States.RESOLVED, value);
-  };
-
-  /** JSDoc */
-  private readonly _reject = (reason?: any) => {
-    this._setResult(States.REJECTED, reason);
-  };
-
-  /** JSDoc */
-  private readonly _setResult = (state: States, value?: T | PromiseLike<T> | any) => {
-    if (this._state !== States.PENDING) {
-      return;
-    }
-
-    if (isThenable(value)) {
-      void (value as PromiseLike<T>).then(this._resolve, this._reject);
-      return;
-    }
-
-    this._state = state;
-    this._value = value;
-
-    this._executeHandlers();
-  };
-
-  /** JSDoc */
-  private readonly _executeHandlers = () => {
-    if (this._state === States.PENDING) {
-      return;
-    }
-
-    const cachedHandlers = this._handlers.slice();
-    this._handlers = [];
-
-    cachedHandlers.forEach(handler => {
-      if (handler[0]) {
-        return;
-      }
-
-      if (this._state === States.RESOLVED) {
-        handler[1](this._value as unknown as any);
-      }
-
-      if (this._state === States.REJECTED) {
-        handler[2](this._value);
-      }
-
-      handler[0] = true;
-    });
-  };
 }
-
-export { SyncPromise };

packages/eslint-plugin-sdk/src/rules/no-class-field-initializers.js

@@ -29,14 +29,7 @@ module.exports = {
   create(context) {
     return {
       'ClassProperty, PropertyDefinition'(node) {
-        // We do allow arrow functions being initialized directly
-        if (
-          !node.static &&
-          node.value !== null &&
-          node.value.type !== 'ArrowFunctionExpression' &&
-          node.value.type !== 'FunctionExpression' &&
-          node.value.type !== 'CallExpression'
-        ) {
+        if (node.value !== null) {
           context.report({
             node,
             message: `Avoid class field initializers. Property "${node.key.name}" should be initialized in the constructor.`,

packages/nestjs/src/integrations/sentry-nest-event-instrumentation.ts

@@ -5,6 +5,7 @@ import {
   InstrumentationNodeModuleDefinition,
   InstrumentationNodeModuleFile,
 } from '@opentelemetry/instrumentation';
+import type { SpanAttributes } from '@sentry/core';
 import { SDK_VERSION, captureException, startSpan } from '@sentry/core';
 import { getEventSpanOptions } from './helpers';
 import type { OnEventTarget } from './types';
@@ -17,23 +18,23 @@ const supportedVersions = ['>=2.0.0'];
  * This hooks into the `OnEvent` decorator, which is applied on event handlers.
  */
 export class SentryNestEventInstrumentation extends InstrumentationBase {
-  public static readonly COMPONENT = '@nestjs/event-emitter';
-  public static readonly COMMON_ATTRIBUTES = {
-    component: SentryNestEventInstrumentation.COMPONENT,
-  };
+  public readonly COMPONENT: string;
+  public readonly COMMON_ATTRIBUTES: SpanAttributes;
 
   public constructor(config: InstrumentationConfig = {}) {
     super('sentry-nestjs-event', SDK_VERSION, config);
+
+    this.COMPONENT = '@nestjs/event-emitter';
+    this.COMMON_ATTRIBUTES = {
+      component: this.COMPONENT,
+    };
   }
 
   /**
    * Initializes the instrumentation by defining the modules to be patched.
    */
   public init(): InstrumentationNodeModuleDefinition {
-    const moduleDef = new InstrumentationNodeModuleDefinition(
-      SentryNestEventInstrumentation.COMPONENT,
-      supportedVersions,
-    );
+    const moduleDef = new InstrumentationNodeModuleDefinition(this.COMPONENT, supportedVersions);
 
     moduleDef.files.push(this._getOnEventFileInstrumentation(supportedVersions));
     return moduleDef;

packages/nestjs/src/integrations/sentry-nest-instrumentation.ts

@@ -5,7 +5,7 @@ import {
   InstrumentationNodeModuleDefinition,
   InstrumentationNodeModuleFile,
 } from '@opentelemetry/instrumentation';
-import type { Span } from '@sentry/core';
+import type { Span, SpanAttributes } from '@sentry/core';
 import {
   SDK_VERSION,
   addNonEnumerableProperty,
@@ -29,20 +29,23 @@ const supportedVersions = ['>=8.0.0 <11'];
  * 2. @Catch decorator, which is applied on exception filters.
  */
 export class SentryNestInstrumentation extends InstrumentationBase {
-  public static readonly COMPONENT = '@nestjs/common';
-  public static readonly COMMON_ATTRIBUTES = {
-    component: SentryNestInstrumentation.COMPONENT,
-  };
+  public readonly COMPONENT: string;
+  public readonly COMMON_ATTRIBUTES: SpanAttributes;
 
   public constructor(config: InstrumentationConfig = {}) {
     super('sentry-nestjs', SDK_VERSION, config);
+
+    this.COMPONENT = '@nestjs/common';
+    this.COMMON_ATTRIBUTES = {
+      component: this.COMPONENT,
+    };
   }
 
   /**
    * Initializes the instrumentation by defining the modules to be patched.
    */
   public init(): InstrumentationNodeModuleDefinition {
-    const moduleDef = new InstrumentationNodeModuleDefinition(SentryNestInstrumentation.COMPONENT, supportedVersions);
+    const moduleDef = new InstrumentationNodeModuleDefinition(this.COMPONENT, supportedVersions);
 
     moduleDef.files.push(
       this._getInjectableFileInstrumentation(supportedVersions),

packages/react/src/errorboundary.tsx

@@ -145,14 +145,14 @@ class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundarySta
     }
   }
 
-  public resetErrorBoundary: () => void = () => {
+  public resetErrorBoundary(): void {
     const { onReset } = this.props;
     const { error, componentStack, eventId } = this.state;
     if (onReset) {
       onReset(error, componentStack, eventId);
     }
     this.setState(INITIAL_STATE);
-  };
+  }
 
   public render(): React.ReactNode {
     const { fallback, children } = this.props;
@@ -164,7 +164,7 @@ class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundarySta
         element = React.createElement(fallback, {
           error: state.error,
           componentStack: state.componentStack as string,
-          resetError: this.resetErrorBoundary,
+          resetError: this.resetErrorBoundary.bind(this),
           eventId: state.eventId as string,
         });
       } else {