feat: Avoid class fields all-together (#14887)

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.

Found as part of
#14882

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.
@@ -208,6 +210,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';
 
@@ -40,29 +39,25 @@ export function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {
   });
 }
 
+type Executor<T> = (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void;
+
 /**
  * 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;
 
-  public constructor(
-    executor: (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void,
-  ) {
+  public constructor(executor: Executor<T>) {
     this._state = States.PENDING;
     this._handlers = [];
 
-    try {
-      executor(this._resolve, this._reject);
-    } catch (e) {
-      this._reject(e);
-    }
+    this._runExecutor(executor);
   }
 
-  /** JSDoc */
+  /** @inheritdoc */
   public then<TResult1 = T, TResult2 = never>(
     onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
@@ -99,14 +94,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;
@@ -138,35 +133,8 @@ 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 = () => {
+  /** Excute the resolve/reject handlers. */
+  private _executeHandlers(): void {
     if (this._state === States.PENDING) {
       return;
     }
@@ -189,7 +157,38 @@ class SyncPromise<T> implements PromiseLike<T> {
 
       handler[0] = true;
     });
-  };
-}
+  }
 
-export { SyncPromise };
+  /** Run the executor for the SyncPromise. */
+  private _runExecutor(executor: Executor<T>): void {
+    const setResult = (state: States, value?: T | PromiseLike<T> | any): void => {
+      if (this._state !== States.PENDING) {
+        return;
+      }
+
+      if (isThenable(value)) {
+        void (value as PromiseLike<T>).then(resolve, reject);
+        return;
+      }
+
+      this._state = state;
+      this._value = value;
+
+      this._executeHandlers();
+    };
+
+    const resolve = (value: unknown): void => {
+      setResult(States.RESOLVED, value);
+    };
+
+    const reject = (reason: unknown): void => {
+      setResult(States.REJECTED, reason);
+    };
+
+    try {
+      executor(resolve, reject);
+    } catch (e) {
+      reject(e);
+    }
+  }
+}

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

@@ -10,18 +10,14 @@ import { getEventSpanOptions } from './helpers';
 import type { OnEventTarget } from './types';
 
 const supportedVersions = ['>=2.0.0'];
+const COMPONENT = '@nestjs/event-emitter';
 
 /**
  * Custom instrumentation for nestjs event-emitter
  *
  * 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 constructor(config: InstrumentationConfig = {}) {
     super('sentry-nestjs-event', SDK_VERSION, config);
   }
@@ -30,10 +26,7 @@ export class SentryNestEventInstrumentation extends InstrumentationBase {
    * Initializes the instrumentation by defining the modules to be patched.
    */
   public init(): InstrumentationNodeModuleDefinition {
-    const moduleDef = new InstrumentationNodeModuleDefinition(
-      SentryNestEventInstrumentation.COMPONENT,
-      supportedVersions,
-    );
+    const moduleDef = new InstrumentationNodeModuleDefinition(COMPONENT, supportedVersions);
 
     moduleDef.files.push(this._getOnEventFileInstrumentation(supportedVersions));
     return moduleDef;

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

@@ -20,6 +20,7 @@ import { getMiddlewareSpanOptions, getNextProxy, instrumentObservable, isPatched
 import type { CallHandler, CatchTarget, InjectableTarget, MinimalNestJsExecutionContext, Observable } from './types';
 
 const supportedVersions = ['>=8.0.0 <11'];
+const COMPONENT = '@nestjs/common';
 
 /**
  * Custom instrumentation for nestjs.
@@ -29,11 +30,6 @@ 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 constructor(config: InstrumentationConfig = {}) {
     super('sentry-nestjs', SDK_VERSION, config);
   }
@@ -42,7 +38,7 @@ export class SentryNestInstrumentation extends InstrumentationBase {
    * Initializes the instrumentation by defining the modules to be patched.
    */
   public init(): InstrumentationNodeModuleDefinition {
-    const moduleDef = new InstrumentationNodeModuleDefinition(SentryNestInstrumentation.COMPONENT, supportedVersions);
+    const moduleDef = new InstrumentationNodeModuleDefinition(COMPONENT, supportedVersions);
 
     moduleDef.files.push(
       this._getInjectableFileInstrumentation(supportedVersions),