ref: Use getCurrentScope() / getClient instead of hub.xxx

packages/angular/src/tracing.ts

@@ -7,7 +7,7 @@ import type { ActivatedRouteSnapshot, Event, RouterState } from '@angular/router
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import { NavigationCancel, NavigationError, Router } from '@angular/router';
 import { NavigationEnd, NavigationStart, ResolveEnd } from '@angular/router';
-import { WINDOW, getCurrentHub } from '@sentry/browser';
+import { WINDOW, getCurrentScope } from '@sentry/browser';
 import type { Span, Transaction, TransactionContext } from '@sentry/types';
 import { logger, stripUrlQueryAndFragment, timestampInSeconds } from '@sentry/utils';
 import type { Observable } from 'rxjs';
@@ -50,14 +50,7 @@ export const instrumentAngularRouting = routingInstrumentation;
  * Grabs active transaction off scope
  */
 export function getActiveTransaction(): Transaction | undefined {
-  const currentHub = getCurrentHub();
-
-  if (currentHub) {
-    const scope = currentHub.getScope();
-    return scope.getTransaction();
-  }
-
-  return undefined;
+  return getCurrentScope().getTransaction();
 }
 
 /**

packages/angular/test/tracing.test.ts

@@ -21,16 +21,12 @@ jest.mock('@sentry/browser', () => {
   const original = jest.requireActual('@sentry/browser');
   return {
     ...original,
-    getCurrentHub: () => {
+    getCurrentScope() {
       return {
-        getScope: () => {
-          return {
-            getTransaction: () => {
-              return transaction;
-            },
-          };
+        getTransaction: () => {
+          return transaction;
         },
-      } as unknown as Hub;
+      };
     },
   };
 });

packages/astro/src/server/meta.ts

@@ -1,5 +1,5 @@
 import { getDynamicSamplingContextFromClient } from '@sentry/core';
-import type { Hub, Span } from '@sentry/types';
+import type { Client, Scope, Span } from '@sentry/types';
 import {
   TRACEPARENT_REGEXP,
   dynamicSamplingContextToSentryBaggageHeader,
@@ -22,9 +22,11 @@ import {
  *
  * @returns an object with the two serialized <meta> tags
  */
-export function getTracingMetaTags(span: Span | undefined, hub: Hub): { sentryTrace: string; baggage?: string } {
-  const scope = hub.getScope();
-  const client = hub.getClient();
+export function getTracingMetaTags(
+  span: Span | undefined,
+  scope: Scope,
+  client: Client | undefined,
+): { sentryTrace: string; baggage?: string } {
   const { dsc, sampled, traceId } = scope.getPropagationContext();
   const transaction = span?.transaction;
 

packages/astro/src/server/middleware.ts

@@ -1,12 +1,12 @@
 import {
   captureException,
   continueTrace,
-  getCurrentHub,
+  getClient,
   getCurrentScope,
   runWithAsyncContext,
   startSpan,
 } from '@sentry/node';
-import type { Hub, Span } from '@sentry/types';
+import type { Client, Scope, Span } from '@sentry/types';
 import { addNonEnumerableProperty, objectify, stripUrlQueryAndFragment } from '@sentry/utils';
 import type { APIContext, MiddlewareResponseHandler } from 'astro';
 
@@ -69,7 +69,7 @@ export const handleRequest: (options?: MiddlewareOptions) => MiddlewareResponseH
     // if there is an active span, we know that this handle call is nested and hence
     // we don't create a new domain for it. If we created one, nested server calls would
     // create new transactions instead of adding a child span to the currently active span.
-    if (getCurrentHub().getScope().getSpan()) {
+    if (getCurrentScope().getSpan()) {
       return instrumentRequest(ctx, next, handlerOptions);
     }
     return runWithAsyncContext(() => {
@@ -139,8 +139,8 @@ async function instrumentRequest(
           span.setHttpStatus(originalResponse.status);
         }
 
-        const hub = getCurrentHub();
-        const client = hub.getClient();
+        const scope = getCurrentScope();
+        const client = getClient();
         const contentType = originalResponse.headers.get('content-type');
 
         const isPageloadRequest = contentType && contentType.startsWith('text/html');
@@ -163,7 +163,7 @@ async function instrumentRequest(
           start: async controller => {
             for await (const chunk of originalBody) {
               const html = typeof chunk === 'string' ? chunk : decoder.decode(chunk);
-              const modifiedHtml = addMetaTagToHead(html, hub, span);
+              const modifiedHtml = addMetaTagToHead(html, scope, client, span);
               controller.enqueue(new TextEncoder().encode(modifiedHtml));
             }
             controller.close();
@@ -185,12 +185,12 @@ async function instrumentRequest(
  * This function optimistically assumes that the HTML coming in chunks will not be split
  * within the <head> tag. If this still happens, we simply won't replace anything.
  */
-function addMetaTagToHead(htmlChunk: string, hub: Hub, span?: Span): string {
+function addMetaTagToHead(htmlChunk: string, scope: Scope, client: Client, span?: Span): string {
   if (typeof htmlChunk !== 'string') {
     return htmlChunk;
   }
 
-  const { sentryTrace, baggage } = getTracingMetaTags(span, hub);
+  const { sentryTrace, baggage } = getTracingMetaTags(span, scope, client);
   const content = `<head>\n${sentryTrace}\n${baggage}\n`;
   return htmlChunk.replace('<head>', content);
 }

packages/astro/test/server/meta.test.ts

@@ -10,22 +10,20 @@ const mockedSpan = {
       environment: 'production',
     }),
   },
-};
+} as any;
 
-const mockedHub = {
-  getScope: () => ({
-    getPropagationContext: () => ({
-      traceId: '123',
-    }),
+const mockedClient = {} as any;
+
+const mockedScope = {
+  getPropagationContext: () => ({
+    traceId: '123',
   }),
-  getClient: () => ({}),
-};
+} as any;
 
 describe('getTracingMetaTags', () => {
   it('returns the tracing tags from the span, if it is provided', () => {
     {
-      // @ts-expect-error - only passing a partial span object
-      const tags = getTracingMetaTags(mockedSpan, mockedHub);
+      const tags = getTracingMetaTags(mockedSpan, mockedScope, mockedClient);
 
       expect(tags).toEqual({
         sentryTrace: '<meta name="sentry-trace" content="12345678901234567890123456789012-1234567890123456-1"/>',
@@ -35,10 +33,9 @@ describe('getTracingMetaTags', () => {
   });
 
   it('returns propagationContext DSC data if no span is available', () => {
-    const tags = getTracingMetaTags(undefined, {
-      ...mockedHub,
-      // @ts-expect-error - only passing a partial scope object
-      getScope: () => ({
+    const tags = getTracingMetaTags(
+      undefined,
+      {
         getPropagationContext: () => ({
           traceId: '12345678901234567890123456789012',
           sampled: true,
@@ -49,8 +46,9 @@ describe('getTracingMetaTags', () => {
             trace_id: '12345678901234567890123456789012',
           },
         }),
-      }),
-    });
+      } as any,
+      mockedClient,
+    );
 
     expect(tags).toEqual({
       sentryTrace: expect.stringMatching(
@@ -73,7 +71,8 @@ describe('getTracingMetaTags', () => {
         toTraceparent: () => '12345678901234567890123456789012-1234567890123456-1',
         transaction: undefined,
       },
-      mockedHub,
+      mockedScope,
+      mockedClient,
     );
 
     expect(tags).toEqual({
@@ -93,10 +92,8 @@ describe('getTracingMetaTags', () => {
         toTraceparent: () => '12345678901234567890123456789012-1234567890123456-1',
         transaction: undefined,
       },
-      {
-        ...mockedHub,
-        getClient: () => undefined,
-      },
+      mockedScope,
+      undefined,
     );
 
     expect(tags).toEqual({

packages/astro/test/server/middleware.test.ts

@@ -1,5 +1,6 @@
 import * as SentryNode from '@sentry/node';
-import { vi } from 'vitest';
+import type { Client } from '@sentry/types';
+import { SpyInstance, vi } from 'vitest';
 
 import { handleRequest, interpolateRouteFromUrlAndParams } from '../../src/server/middleware';
 
@@ -14,14 +15,17 @@ describe('sentryMiddleware', () => {
   const startSpanSpy = vi.spyOn(SentryNode, 'startSpan');
 
   const getSpanMock = vi.fn(() => {});
-  // @ts-expect-error only returning a partial hub here
-  vi.spyOn(SentryNode, 'getCurrentHub').mockImplementation(() => {
-    return {
-      getScope: () => ({
+  const setUserMock = vi.fn();
+
+  beforeEach(() => {
+    vi.spyOn(SentryNode, 'getCurrentScope').mockImplementation(() => {
+      return {
+        setUser: setUserMock,
+        setPropagationContext: vi.fn(),
         getSpan: getSpanMock,
-      }),
-      getClient: () => ({}),
-    };
+      } as any;
+    });
+    vi.spyOn(SentryNode, 'getClient').mockImplementation(() => ({}) as Client);
   });
 
   const nextResult = Promise.resolve(new Response(null, { status: 200, headers: new Headers() }));
@@ -170,10 +174,6 @@ describe('sentryMiddleware', () => {
   });
 
   it('attaches client IP and request headers if options are set', async () => {
-    const scope = { setUser: vi.fn(), setPropagationContext: vi.fn() };
-    // @ts-expect-error, only passing a partial Scope object
-    const getCurrentScopeSpy = vi.spyOn(SentryNode, 'getCurrentScope').mockImplementation(() => scope);
-
     const middleware = handleRequest({ trackClientIp: true, trackHeaders: true });
     const ctx = {
       request: {
@@ -192,8 +192,7 @@ describe('sentryMiddleware', () => {
     // @ts-expect-error, a partial ctx object is fine here
     await middleware(ctx, next);
 
-    expect(getCurrentScopeSpy).toHaveBeenCalledTimes(1);
-    expect(scope.setUser).toHaveBeenCalledWith({ ip_address: '192.168.0.1' });
+    expect(setUserMock).toHaveBeenCalledWith({ ip_address: '192.168.0.1' });
 
     expect(startSpanSpy).toHaveBeenCalledWith(
       expect.objectContaining({

packages/browser/src/eventbuilder.ts

@@ -1,4 +1,4 @@
-import { getCurrentHub } from '@sentry/core';
+import { getClient } from '@sentry/core';
 import type { Event, EventHint, Exception, Severity, SeverityLevel, StackFrame, StackParser } from '@sentry/types';
 import {
   addExceptionMechanism,
@@ -48,8 +48,7 @@ export function eventFromPlainObject(
   syntheticException?: Error,
   isUnhandledRejection?: boolean,
 ): Event {
-  const hub = getCurrentHub();
-  const client = hub.getClient();
+  const client = getClient();
   const normalizeDepth = client && client.getOptions().normalizeDepth;
 
   const event: Event = {

packages/browser/src/profiling/utils.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 
-import { DEFAULT_ENVIRONMENT, getClient, getCurrentHub } from '@sentry/core';
+import { DEFAULT_ENVIRONMENT, getClient } from '@sentry/core';
 import type { DebugImage, Envelope, Event, EventEnvelope, StackFrame, StackParser, Transaction } from '@sentry/types';
 import type { Profile, ThreadCpuProfile } from '@sentry/types/src/profiling';
 import { GLOBAL_OBJ, browserPerformanceTimeOrigin, forEachEnvelopeItem, logger, uuid4 } from '@sentry/utils';
@@ -347,19 +347,10 @@ export function applyDebugMetadata(resource_paths: ReadonlyArray<string>): Debug
     return [];
   }
 
-  const hub = getCurrentHub();
-  if (!hub) {
-    return [];
-  }
-  const client = hub.getClient();
-  if (!client) {
-    return [];
-  }
-  const options = client.getOptions();
-  if (!options) {
-    return [];
-  }
-  const stackParser = options.stackParser;
+  const client = getClient();
+  const options = client && client.getOptions();
+  const stackParser = options && options.stackParser;
+
   if (!stackParser) {
     return [];
   }

packages/core/src/baseclient.ts

@@ -48,7 +48,7 @@ import {
 import { getEnvelopeEndpointWithUrlEncodedAuth } from './api';
 import { DEBUG_BUILD } from './debug-build';
 import { createEventEnvelope, createSessionEnvelope } from './envelope';
-import { getCurrentHub } from './hub';
+import { getClient } from './exports';
 import type { IntegrationIndex } from './integration';
 import { setupIntegration, setupIntegrations } from './integration';
 import { createMetricEnvelope } from './metrics/envelope';
@@ -870,7 +870,7 @@ function isTransactionEvent(event: Event): event is TransactionEvent {
  * This event processor will run for all events processed by this client.
  */
 export function addEventProcessor(callback: EventProcessor): void {
-  const client = getCurrentHub().getClient();
+  const client = getClient();
 
   if (!client || !client.addEventProcessor) {
     return;

packages/core/src/exports.ts

@@ -202,9 +202,8 @@ export function startTransaction(
  * to create a monitor automatically when sending a check in.
  */
 export function captureCheckIn(checkIn: CheckIn, upsertMonitorConfig?: MonitorConfig): string {
-  const hub = getCurrentHub();
-  const scope = hub.getScope();
-  const client = hub.getClient();
+  const scope = getCurrentScope();
+  const client = getClient();
   if (!client) {
     DEBUG_BUILD && logger.warn('Cannot capture check-in. No client defined.');
   } else if (!client.captureCheckIn) {

packages/core/src/metrics/exports.ts

@@ -2,7 +2,7 @@ import type { ClientOptions, MeasurementUnit, Primitive } from '@sentry/types';
 import { logger } from '@sentry/utils';
 import type { BaseClient } from '../baseclient';
 import { DEBUG_BUILD } from '../debug-build';
-import { getCurrentHub } from '../hub';
+import { getClient, getCurrentScope } from '../exports';
 import { COUNTER_METRIC_TYPE, DISTRIBUTION_METRIC_TYPE, GAUGE_METRIC_TYPE, SET_METRIC_TYPE } from './constants';
 import { MetricsAggregator } from './integration';
 import type { MetricType } from './types';
@@ -19,9 +19,8 @@ function addToMetricsAggregator(
   value: number | string,
   data: MetricData = {},
 ): void {
-  const hub = getCurrentHub();
-  const client = hub.getClient() as BaseClient<ClientOptions>;
-  const scope = hub.getScope();
+  const client = getClient<BaseClient<ClientOptions>>();
+  const scope = getCurrentScope();
   if (client) {
     if (!client.metricsAggregator) {
       DEBUG_BUILD &&

packages/core/src/sessionflusher.ts

@@ -6,8 +6,7 @@ import type {
   SessionFlusherLike,
 } from '@sentry/types';
 import { dropUndefinedKeys } from '@sentry/utils';
-
-import { getCurrentHub } from './hub';
+import { getCurrentScope } from './exports';
 
 type ReleaseHealthAttributes = {
   environment?: string;
@@ -75,7 +74,7 @@ export class SessionFlusher implements SessionFlusherLike {
     if (!this._isEnabled) {
       return;
     }
-    const scope = getCurrentHub().getScope();
+    const scope = getCurrentScope();
     const requestSession = scope.getRequestSession();
 
     if (requestSession && requestSession.status) {