ref(core): Remove scope.setSpan() and scope.getSpan() methods

Instead, we have an internal utility for this now.

Author: mydea

dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/subject.js

@@ -6,9 +6,8 @@ document.getElementById('go-background').addEventListener('click', () => {
 });
 
 document.getElementById('start-span').addEventListener('click', () => {
-  const span = Sentry.startInactiveSpan({ name: 'test-span' });
+  const span = Sentry.startBrowserTracingNavigationSpan({ name: 'test-span' });
   window.span = span;
-  Sentry.getCurrentScope().setSpan(span);
 });
 
 window.getSpanJson = () => {

dev-packages/e2e-tests/test-applications/nextjs-app-dir/components/span-context.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { getCurrentScope, startInactiveSpan } from '@sentry/nextjs';
+import { startInactiveSpan } from '@sentry/nextjs';
 import { Span } from '@sentry/types';
 import { PropsWithChildren, createContext, useState } from 'react';
 
@@ -29,7 +29,6 @@ export function SpanContextProvider({ children }: PropsWithChildren) {
               spanActive: false,
               start: (spanName: string) => {
                 const span = startInactiveSpan({ name: spanName });
-                getCurrentScope().setSpan(span);
                 setSpan(span);
               },
             }

packages/core/src/fetch.ts

@@ -127,11 +127,8 @@ export function addTracingHeadersToFetchRequest(
         }
       | PolymorphicRequestHeaders;
   },
-  requestSpan?: Span,
+  span?: Span,
 ): PolymorphicRequestHeaders | undefined {
-  // eslint-disable-next-line deprecation/deprecation
-  const span = requestSpan || scope.getSpan();
-
   const isolationScope = getIsolationScope();
 
   const { traceId, spanId, sampled, dsc } = {

packages/core/src/scope.ts

@@ -19,14 +19,14 @@ import type {
   ScopeData,
   Session,
   SeverityLevel,
-  Span,
   Transaction,
   User,
 } from '@sentry/types';
 import { dateTimestampInSeconds, isPlainObject, logger, uuid4 } from '@sentry/utils';
 
 import { updateSession } from './session';
 import type { SentrySpan } from './tracing/sentrySpan';
+import { _getSpanForScope, _setSpanForScope } from './utils/spanUtils';
 
 /**
  * Default value for maximum number of breadcrumbs added to an event.
@@ -87,9 +87,6 @@ export class Scope implements ScopeInterface {
    */
   protected _transactionName?: string;
 
-  /** Span */
-  protected _span?: Span;
-
   /** Session */
   protected _session?: Session;
 
@@ -134,7 +131,6 @@ export class Scope implements ScopeInterface {
     newScope._contexts = { ...this._contexts };
     newScope._user = this._user;
     newScope._level = this._level;
-    newScope._span = this._span;
     newScope._session = this._session;
     newScope._transactionName = this._transactionName;
     newScope._fingerprint = this._fingerprint;
@@ -145,6 +141,8 @@ export class Scope implements ScopeInterface {
     newScope._propagationContext = { ...this._propagationContext };
     newScope._client = this._client;
 
+    _setSpanForScope(newScope, _getSpanForScope(this));
+
     return newScope;
   }
 
@@ -304,33 +302,14 @@ export class Scope implements ScopeInterface {
     return this;
   }
 
-  /**
-   * Sets the Span on the scope.
-   * @param span Span
-   * @deprecated Instead of setting a span on a scope, use `startSpan()`/`startSpanManual()` instead.
-   */
-  public setSpan(span?: Span): this {
-    this._span = span;
-    this._notifyScopeListeners();
-    return this;
-  }
-
-  /**
-   * Returns the `Span` if there is one.
-   * @deprecated Use `getActiveSpan()` instead.
-   */
-  public getSpan(): Span | undefined {
-    return this._span;
-  }
-
   /**
    * Returns the `Transaction` attached to the scope (if there is one).
    * @deprecated You should not rely on the transaction, but just use `startSpan()` APIs instead.
    */
   public getTransaction(): Transaction | undefined {
     // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will
     // have a pointer to the currently-active transaction.
-    const span = this._span;
+    const span = _getSpanForScope(this);
 
     // Cannot replace with getRootSpan because getRootSpan returns a span, not a transaction
     // Also, this method will be removed anyway.
@@ -432,11 +411,12 @@ export class Scope implements ScopeInterface {
     this._transactionName = undefined;
     this._fingerprint = undefined;
     this._requestSession = undefined;
-    this._span = undefined;
     this._session = undefined;
-    this._notifyScopeListeners();
+    _setSpanForScope(this, undefined);
     this._attachments = [];
     this._propagationContext = generatePropagationContext();
+
+    this._notifyScopeListeners();
     return this;
   }
 
@@ -522,7 +502,6 @@ export class Scope implements ScopeInterface {
       _propagationContext,
       _sdkProcessingMetadata,
       _transactionName,
-      _span,
     } = this;
 
     return {
@@ -538,7 +517,7 @@ export class Scope implements ScopeInterface {
       propagationContext: _propagationContext,
       sdkProcessingMetadata: _sdkProcessingMetadata,
       transactionName: _transactionName,
-      span: _span,
+      span: _getSpanForScope(this),
     };
   }
 

packages/core/src/server-runtime-client.ts

@@ -24,7 +24,7 @@ import {
   getDynamicSamplingContextFromClient,
   getDynamicSamplingContextFromSpan,
 } from './tracing';
-import { getRootSpan, spanToTraceContext } from './utils/spanUtils';
+import { _getSpanForScope, getRootSpan, spanToTraceContext } from './utils/spanUtils';
 
 export interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportOptions> {
   platform?: string;
@@ -252,8 +252,7 @@ export class ServerRuntimeClient<
       return [undefined, undefined];
     }
 
-    // eslint-disable-next-line deprecation/deprecation
-    const span = scope.getSpan();
+    const span = _getSpanForScope(scope);
     if (span) {
       const rootSpan = getRootSpan(span);
       const samplingContext = getDynamicSamplingContextFromSpan(rootSpan);

packages/core/src/tracing/idleSpan.ts

@@ -6,6 +6,7 @@ import { DEBUG_BUILD } from '../debug-build';
 import { SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON } from '../semanticAttributes';
 import { hasTracingEnabled } from '../utils/hasTracingEnabled';
 import {
+  _setSpanForScope,
   getActiveSpan,
   getSpanDescendants,
   removeChildSpanFromSpan,
@@ -232,8 +233,7 @@ export function startIdleSpan(startSpanOptions: StartSpanOptions, options: Parti
       beforeSpanEnd(span);
     }
 
-    // eslint-disable-next-line deprecation/deprecation
-    scope.setSpan(previousActiveSpan);
+    _setSpanForScope(scope, previousActiveSpan);
 
     const spanJSON = spanToJSON(span);
 
@@ -347,8 +347,7 @@ export function startIdleSpan(startSpanOptions: StartSpanOptions, options: Parti
 function _startIdleSpan(options: StartSpanOptions): Span {
   const span = startInactiveSpan(options);
 
-  // eslint-disable-next-line deprecation/deprecation
-  getCurrentScope().setSpan(span);
+  _setSpanForScope(getCurrentScope(), span);
 
   DEBUG_BUILD && logger.log(`Setting idle span on scope. Span ID: ${span.spanContext().spanId}`);
 

packages/core/src/tracing/trace.ts

@@ -1,12 +1,4 @@
-import type {
-  ClientOptions,
-  Hub,
-  Scope,
-  Span,
-  SpanTimeInput,
-  StartSpanOptions,
-  TransactionContext,
-} from '@sentry/types';
+import type { ClientOptions, Scope, Span, SpanTimeInput, StartSpanOptions, TransactionContext } from '@sentry/types';
 
 import { propagationContextFromHeaders } from '@sentry/utils';
 import type { AsyncContextStrategy } from '../asyncContext';
@@ -17,6 +9,8 @@ import { getAsyncContextStrategy, getCurrentHub } from '../hub';
 import { handleCallbackErrors } from '../utils/handleCallbackErrors';
 import { hasTracingEnabled } from '../utils/hasTracingEnabled';
 import {
+  _getSpanForScope,
+  _setSpanForScope,
   addChildSpanToSpan,
   getActiveSpan,
   spanIsSampled,
@@ -34,13 +28,12 @@ import { setCapturedScopesOnSpan } from './utils';
 /**
  * Wraps a function with a transaction/span and finishes the span after the function is done.
  * The created span is the active span and will be used as parent by other spans created inside the function
- * and can be accessed via `Sentry.getSpan()`, as long as the function is executed while the scope is active.
+ * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.
  *
  * If you want to create a span that is not set as active, use {@link startInactiveSpan}.
  *
- * Note that if you have not enabled tracing extensions via `addTracingExtensions`
- * or you didn't set `tracesSampleRate`, this function will not generate spans
- * and the `span` returned from the callback will be undefined.
+ * You'll always get a span passed to the callback,
+ * it may just be a non-recording span if the span is not sampled or if tracing is disabled.
  */
 export function startSpan<T>(context: StartSpanOptions, callback: (span: Span) => T): T {
   const acs = getAcs();
@@ -51,23 +44,19 @@ export function startSpan<T>(context: StartSpanOptions, callback: (span: Span) =
   const spanContext = normalizeContext(context);
 
   return withScope(context.scope, scope => {
-    // eslint-disable-next-line deprecation/deprecation
-    const hub = getCurrentHub();
-    // eslint-disable-next-line deprecation/deprecation
-    const parentSpan = scope.getSpan() as SentrySpan | undefined;
+    const parentSpan = _getSpanForScope(scope) as SentrySpan | undefined;
 
     const shouldSkipSpan = context.onlyIfParent && !parentSpan;
     const activeSpan = shouldSkipSpan
       ? new SentryNonRecordingSpan()
-      : createChildSpanOrTransaction(hub, {
+      : createChildSpanOrTransaction({
           parentSpan,
           spanContext,
           forceTransaction: context.forceTransaction,
           scope,
         });
 
-    // eslint-disable-next-line deprecation/deprecation
-    scope.setSpan(activeSpan);
+    _setSpanForScope(scope, activeSpan);
 
     return handleCallbackErrors(
       () => callback(activeSpan),
@@ -90,9 +79,8 @@ export function startSpan<T>(context: StartSpanOptions, callback: (span: Span) =
  * The created span is the active span and will be used as parent by other spans created inside the function
  * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.
  *
- * Note that if you have not enabled tracing extensions via `addTracingExtensions`
- * or you didn't set `tracesSampleRate`, this function will not generate spans
- * and the `span` returned from the callback will be undefined.
+ * You'll always get a span passed to the callback,
+ * it may just be a non-recording span if the span is not sampled or if tracing is disabled.
  */
 export function startSpanManual<T>(context: StartSpanOptions, callback: (span: Span, finish: () => void) => T): T {
   const acs = getAcs();
@@ -103,23 +91,19 @@ export function startSpanManual<T>(context: StartSpanOptions, callback: (span: S
   const spanContext = normalizeContext(context);
 
   return withScope(context.scope, scope => {
-    // eslint-disable-next-line deprecation/deprecation
-    const hub = getCurrentHub();
-    // eslint-disable-next-line deprecation/deprecation
-    const parentSpan = scope.getSpan() as SentrySpan | undefined;
+    const parentSpan = _getSpanForScope(scope) as SentrySpan | undefined;
 
     const shouldSkipSpan = context.onlyIfParent && !parentSpan;
     const activeSpan = shouldSkipSpan
       ? new SentryNonRecordingSpan()
-      : createChildSpanOrTransaction(hub, {
+      : createChildSpanOrTransaction({
           parentSpan,
           spanContext,
           forceTransaction: context.forceTransaction,
           scope,
         });
 
-    // eslint-disable-next-line deprecation/deprecation
-    scope.setSpan(activeSpan);
+    _setSpanForScope(scope, activeSpan);
 
     function finishAndSetSpan(): void {
       activeSpan.end();
@@ -140,13 +124,12 @@ export function startSpanManual<T>(context: StartSpanOptions, callback: (span: S
 
 /**
  * Creates a span. This span is not set as active, so will not get automatic instrumentation spans
- * as children or be able to be accessed via `Sentry.getSpan()`.
+ * as children or be able to be accessed via `Sentry.getActiveSpan()`.
  *
  * If you want to create a span that is set as active, use {@link startSpan}.
  *
- * Note that if you have not enabled tracing extensions via `addTracingExtensions`
- * or you didn't set `tracesSampleRate` or `tracesSampler`, this function will not generate spans
- * and the `span` returned from the callback will be undefined.
+ * This function will always return a span,
+ * it may just be a non-recording span if the span is not sampled or if tracing is disabled.
  */
 export function startInactiveSpan(context: StartSpanOptions): Span {
   const acs = getAcs();
@@ -155,11 +138,8 @@ export function startInactiveSpan(context: StartSpanOptions): Span {
   }
 
   const spanContext = normalizeContext(context);
-  // eslint-disable-next-line deprecation/deprecation
-  const hub = getCurrentHub();
   const parentSpan = context.scope
-    ? // eslint-disable-next-line deprecation/deprecation
-      (context.scope.getSpan() as SentrySpan | undefined)
+    ? (_getSpanForScope(context.scope) as SentrySpan | undefined)
     : (getActiveSpan() as SentrySpan | undefined);
 
   const shouldSkipSpan = context.onlyIfParent && !parentSpan;
@@ -170,7 +150,7 @@ export function startInactiveSpan(context: StartSpanOptions): Span {
 
   const scope = context.scope || getCurrentScope();
 
-  return createChildSpanOrTransaction(hub, {
+  return createChildSpanOrTransaction({
     parentSpan,
     spanContext,
     forceTransaction: context.forceTransaction,
@@ -219,26 +199,22 @@ export function withActiveSpan<T>(span: Span | null, callback: (scope: Scope) =>
   }
 
   return withScope(scope => {
-    // eslint-disable-next-line deprecation/deprecation
-    scope.setSpan(span || undefined);
+    _setSpanForScope(scope, span || undefined);
     return callback(scope);
   });
 }
 
-function createChildSpanOrTransaction(
-  hub: Hub,
-  {
-    parentSpan,
-    spanContext,
-    forceTransaction,
-    scope,
-  }: {
-    parentSpan: SentrySpan | undefined;
-    spanContext: TransactionContext;
-    forceTransaction?: boolean;
-    scope: Scope;
-  },
-): Span {
+function createChildSpanOrTransaction({
+  parentSpan,
+  spanContext,
+  forceTransaction,
+  scope,
+}: {
+  parentSpan: SentrySpan | undefined;
+  spanContext: TransactionContext;
+  forceTransaction?: boolean;
+  scope: Scope;
+}): Span {
   if (!hasTracingEnabled()) {
     return new SentryNonRecordingSpan();
   }