ref(core): Use versioned carrier on global object

Lms24 · Lms24 · commit 8a45505db9cb · 2024-05-24T12:39:28.000+02:00
diff --git a/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/init.js b/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/init.js
@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/browser';
+
+/**
+ * This simulates an old, pre-v8 SDK setting itself up on the global __SENTRY__ carrier.
+ */
+window.__SENTRY__ = {
+  hub: {
+    isOlderThan: version => {
+      return version < 7;
+    },
+  },
+};
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+});
diff --git a/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/subject.js b/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/subject.js
@@ -0,0 +1,12 @@
+const sentryCarrier = window && window.__SENTRY__;
+
+/**
+ * Simulate an old pre v8 SDK obtaining the hub from the global sentry carrier
+ * and checking for the hub version.
+ */
+const res = sentryCarrier.hub && sentryCarrier.hub.isOlderThan(7);
+
+// Write back result into the document
+document.getElementById('olderThan').innerText = res;
+
+console.log(sentryCarrier);
diff --git a/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/template.html b/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/template.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <p id="olderThan"></p>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/test.ts b/dev-packages/browser-integration-tests/suites/old-sdk-interop/hub/test.ts
@@ -0,0 +1,13 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../utils/fixtures';
+
+sentryTest(
+  "doesn't crash if older SDKs access `hub.isOlderThan` on the global object",
+  async ({ getLocalTestUrl, page }) => {
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
+
+    await expect(page.locator('#olderThan')).toHaveText('false');
+  },
+);
diff --git a/packages/core/src/asyncContext/stackStrategy.ts b/packages/core/src/asyncContext/stackStrategy.ts
@@ -132,29 +132,19 @@ export class AsyncContextStack {
  */
 function getAsyncContextStack(): AsyncContextStack {
   const registry = getMainCarrier();
+  const sentry = getSentryCarrier(registry);
 
-  // For now we continue to keep this as `hub` on the ACS,
-  // as e.g. the Loader Script relies on this.
-  // Eventually we may change this if/when we update the loader to not require this field anymore
-  // Related, we also write to `hub` in {@link ./../sdk.ts registerClientOnGlobalHub}
-  const sentry = getSentryCarrier(registry) as { hub?: AsyncContextStack };
-
-  if (sentry.hub) {
-    return sentry.hub;
-  }
-
-  sentry.hub = new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope());
-  return sentry.hub;
+  return (sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope()));
 }
 
 function withScope<T>(callback: (scope: ScopeInterface) => T): T {
   return getAsyncContextStack().withScope(callback);
 }
 
 function withSetScope<T>(scope: ScopeInterface, callback: (scope: ScopeInterface) => T): T {
-  const hub = getAsyncContextStack() as AsyncContextStack;
-  return hub.withScope(() => {
-    hub.getStackTop().scope = scope;
+  const stack = getAsyncContextStack() as AsyncContextStack;
+  return stack.withScope(() => {
+    stack.getStackTop().scope = scope;
     return callback(scope);
   });
 }
diff --git a/packages/core/src/carrier.ts b/packages/core/src/carrier.ts
@@ -1,11 +1,11 @@
-import type { Integration, VersionString } from '@sentry/types';
+import type { Integration, Scope, VersionString } from '@sentry/types';
 import { GLOBAL_OBJ } from '@sentry/utils';
 import type { AsyncContextStack } from './asyncContext/stackStrategy';
 import type { AsyncContextStrategy } from './asyncContext/types';
 import { SDK_VERSION } from './version';
 
 /**
- * An object that contains a hub and maintains a scope stack.
+ * An object that contains globally accessible properties and maintains a scope stack.
  * @hidden
  */
 export interface Carrier {
@@ -29,6 +29,10 @@ interface SentryCarrier {
     [key: string]: Function;
   };
   stack?: AsyncContextStack;
+
+  globalScope?: Scope;
+  defaultIsolationScope?: Scope;
+  defaultCurrentScope?: Scope;
 }
 
 /**
diff --git a/packages/core/src/integration.ts b/packages/core/src/integration.ts
@@ -146,7 +146,7 @@ export function setupIntegration(client: Client, integration: Integration, integ
   DEBUG_BUILD && logger.log(`Integration installed: ${integration.name}`);
 }
 
-/** Add an integration to the current hub's client. */
+/** Add an integration to the current scope's client. */
 export function addIntegration(integration: Integration): void {
   const client = getClient();
 
diff --git a/packages/core/src/sdk.ts b/packages/core/src/sdk.ts
@@ -47,7 +47,7 @@ export function setCurrentClient(client: Client): void {
 }
 
 /**
- * Unfortunately, we still have to manually bind the client to the "hub" property set on the global
+ * Unfortunately, we still have to manually bind the client to the "stack" property set on the global
  * Sentry carrier object. This is because certain scripts (e.g. our loader script) obtain
  * the client via `window.__SENTRY__[version].stack.getClient()`.
  *
diff --git a/packages/core/src/utils/prepareEvent.ts b/packages/core/src/utils/prepareEvent.ts
@@ -76,7 +76,7 @@ export function prepareEvent(
   const clientEventProcessors = client ? client.getEventProcessors() : [];
 
   // This should be the last thing called, since we want that
-  // {@link Hub.addEventProcessor} gets the finished prepared event.
+  // {@link Scope.addEventProcessor} gets the finished prepared event.
   // Merge scope data together
   const data = getGlobalScope().getScopeData();
 
diff --git a/packages/core/test/lib/clear-global-scope.ts b/packages/core/test/lib/clear-global-scope.ts
@@ -1,6 +1,7 @@
 import { GLOBAL_OBJ } from '@sentry/utils';
+import { getSentryCarrier } from '../../src/carrier';
 
 export function clearGlobalScope() {
-  const __SENTRY__ = (GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {});
-  __SENTRY__.globalScope = undefined;
+  const carrier = getSentryCarrier(GLOBAL_OBJ);
+  carrier.globalScope = undefined;
 }
diff --git a/packages/utils/package.json b/packages/utils/package.json
@@ -67,6 +67,7 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "test:package": "node test/types/index.js",
+    "version": "node ../../scripts/versionbump.js src/version.ts",
     "yalc:publish": "ts-node ../../scripts/prepack.ts && yalc publish build --push --sig"
   },
   "volta": {
diff --git a/packages/utils/src/version.ts b/packages/utils/src/version.ts
@@ -0,0 +1 @@
+export const SDK_VERSION = '8.4.0';
diff --git a/packages/utils/src/worldwide.ts b/packages/utils/src/worldwide.ts
@@ -15,9 +15,33 @@
 import type { Client, MetricsAggregator, Scope, VersionString } from '@sentry/types';
 
 import type { SdkSource } from './env';
+import { SDK_VERSION } from './version';
+
+type BackwardsCompatibleSentryCarrier = {
+  // v8 scope stack (replaces .hub)
+  stack?: any;
+  acs?: any;
+  // pre-v7 hub (replaced by .stack)
+  hub: any;
+  integrations?: any[];
+  logger: any;
+  extensions?: {
+    /** Extension methods for the hub, which are bound to the current Hub instance */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    [key: string]: Function;
+  };
+  globalScope: Scope | undefined;
+  defaultCurrentScope: Scope | undefined;
+  defaultIsolationScope: Scope | undefined;
+  globalMetricsAggregators: WeakMap<Client, MetricsAggregator> | undefined;
+  /** Overwrites TextEncoder used in `@sentry/utils`, need for `react-native@0.73` and older */
+  encodePolyfill?: (input: string) => Uint8Array;
+  /** Overwrites TextDecoder used in `@sentry/utils`, need for `react-native@0.73` and older */
+  decodePolyfill?: (input: Uint8Array) => string;
+};
 
 /** Internal global with common properties and Sentry extensions  */
-export interface InternalGlobal {
+export type InternalGlobal = {
   navigator?: { userAgent?: string };
   console: Console;
   Sentry?: any;
@@ -44,45 +68,23 @@ export interface InternalGlobal {
    */
   _sentryDebugIds?: Record<string, string>;
   __SENTRY__: {
-    [key: VersionString]: {
-      acs?: any;
-      integrations?: any[];
-      extensions?: {
-        /** Extra Hub properties injected by various SDKs */
-        // eslint-disable-next-line @typescript-eslint/ban-types
-        [key: string]: Function;
-      };
-      stack?: any;
-    };
+    [key: VersionString]: BackwardsCompatibleSentryCarrier;
     version: VersionString;
-    hub: any;
-    logger: any;
-    extensions?: {
-      /** Extension methods for the hub, which are bound to the current Hub instance */
-      // eslint-disable-next-line @typescript-eslint/ban-types
-      [key: string]: Function;
-    };
-    globalScope: Scope | undefined;
-    defaultCurrentScope: Scope | undefined;
-    defaultIsolationScope: Scope | undefined;
-    globalMetricsAggregators: WeakMap<Client, MetricsAggregator> | undefined;
-    /** Overwrites TextEncoder used in `@sentry/utils`, need for `react-native@0.73` and older */
-    encodePolyfill?: (input: string) => Uint8Array;
-    /** Overwrites TextDecoder used in `@sentry/utils`, need for `react-native@0.73` and older */
-    decodePolyfill?: (input: Uint8Array) => string;
-  };
+  } & BackwardsCompatibleSentryCarrier;
   /**
    * Raw module metadata that is injected by bundler plugins.
    *
    * Keys are `error.stack` strings, values are the metadata.
    */
   _sentryModuleMetadata?: Record<string, any>;
   _sentryEsmLoaderHookRegistered?: boolean;
-}
+};
 
 /** Get's the global object for the current JavaScript runtime */
 export const GLOBAL_OBJ = globalThis as unknown as InternalGlobal;
 
+type SingletonKeys = Exclude<keyof InternalGlobal['__SENTRY__'], 'version' | VersionString>;
+
 /**
  * Returns a global singleton contained in the global `__SENTRY__` object.
  *
@@ -94,9 +96,10 @@ export const GLOBAL_OBJ = globalThis as unknown as InternalGlobal;
  * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
  * @returns the singleton
  */
-export function getGlobalSingleton<T>(name: keyof InternalGlobal['__SENTRY__'], creator: () => T, obj?: unknown): T {
+export function getGlobalSingleton<T>(name: SingletonKeys, creator: () => T, obj?: unknown): T {
   const gbl = (obj || GLOBAL_OBJ) as InternalGlobal;
   const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});
-  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+  const versionedCarrier = (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});
+  const singleton = versionedCarrier[name] || (versionedCarrier[name] = creator());
   return singleton;
 }

Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ export function setupIntegration(client: Client, integration: Integration, integ`
`146`	`146`	DEBUG_BUILD && logger.log(`Integration installed: ${integration.name}`);
`147`	`147`	`}`
`148`	`148`
`149`		`-/** Add an integration to the current hub's client. */`
	`149`	`+/** Add an integration to the current scope's client. */`
`150`	`150`	`export function addIntegration(integration: Integration): void {`
`151`	`151`	`const client = getClient();`
`152`	`152`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ export function setCurrentClient(client: Client): void {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`/**`
`50`		`- * Unfortunately, we still have to manually bind the client to the "hub" property set on the global`
	`50`	`+ * Unfortunately, we still have to manually bind the client to the "stack" property set on the global`
`51`	`51`	`* Sentry carrier object. This is because certain scripts (e.g. our loader script) obtain`
`52`	`52`	* the client via `window.__SENTRY__[version].stack.getClient()`.
`53`	`53`	`*`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`import { GLOBAL_OBJ } from '@sentry/utils';`
	`2`	`+import { getSentryCarrier } from '../../src/carrier';`
`2`	`3`
`3`	`4`	`export function clearGlobalScope() {`
`4`		`- const __SENTRY__ = (GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ \|\| {});`
`5`		`- __SENTRY__.globalScope = undefined;`
	`5`	`+ const carrier = getSentryCarrier(GLOBAL_OBJ);`
	`6`	`+ carrier.globalScope = undefined;`
`6`	`7`	`}`