@sentry/core 10.53.1 → 10.54.0

package/build/esm/tracing/trace.js

@@ -23,130 +23,75 @@ import { SentrySpan } from './sentrySpan.js';
 import { SPAN_STATUS_ERROR } from './spanstatus.js';
 import { setCapturedScopesOnSpan } from './utils.js';
 
-/* eslint-disable max-lines */
-
-
-const SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';
-
-/**
- * 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.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}.
- *
- * 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.
- */
+const SUPPRESS_TRACING_KEY = "__SENTRY_SUPPRESS_TRACING__";
 function startSpan(options, callback) {
   const acs = getAcs();
   if (acs.startSpan) {
     return acs.startSpan(options, callback);
   }
-
   const spanArguments = parseSentrySpanArguments(options);
   const { forceTransaction, parentSpan: customParentSpan, scope: customScope } = options;
-
-  // We still need to fork a potentially passed scope, as we set the active span on it
-  // and we need to ensure that it is cleaned up properly once the span ends.
   const customForkedScope = customScope?.clone();
-
   return withScope(customForkedScope, () => {
-    // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`
     const wrapper = getActiveSpanWrapper(customParentSpan);
-
     return wrapper(() => {
       const scope = getCurrentScope();
       const parentSpan = getParentSpan(scope, customParentSpan);
       const client = getClient();
-
       const missingRequiredParent = options.onlyIfParent && !parentSpan;
-      const activeSpan = missingRequiredParent
-        ? new SentryNonRecordingSpan()
-        : createChildOrRootSpan({
-            parentSpan,
-            spanArguments,
-            forceTransaction,
-            scope,
-          });
-
+      const activeSpan = missingRequiredParent ? new SentryNonRecordingSpan() : createChildOrRootSpan({
+        parentSpan,
+        spanArguments,
+        forceTransaction,
+        scope
+      });
       if (missingRequiredParent) {
-        client?.recordDroppedEvent('no_parent_span', 'span');
+        client?.recordDroppedEvent("no_parent_span", "span");
       }
-
-      // Ignored root spans still need to be set on scope so that `getActiveSpan()` returns them
-      // and descendants are also non-recording. Ignored child spans don't need this because
-      // the parent span is already on scope.
       if (!_isIgnoredSpan(activeSpan) || !parentSpan) {
         _setSpanForScope(scope, activeSpan);
       }
-
       return handleCallbackErrors(
         () => callback(activeSpan),
         () => {
-          // Only update the span status if it hasn't been changed yet, and the span is not yet finished
           const { status } = spanToJSON(activeSpan);
-          if (activeSpan.isRecording() && (!status || status === 'ok')) {
-            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
+          if (activeSpan.isRecording() && (!status || status === "ok")) {
+            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
           }
         },
         () => {
           activeSpan.end();
-        },
+        }
       );
     });
   });
 }
-
-/**
- * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span
- * after the function is done automatically. Use `span.end()` to end the 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.
- *
- * 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.
- */
 function startSpanManual(options, callback) {
   const acs = getAcs();
   if (acs.startSpanManual) {
     return acs.startSpanManual(options, callback);
   }
-
   const spanArguments = parseSentrySpanArguments(options);
   const { forceTransaction, parentSpan: customParentSpan, scope: customScope } = options;
-
   const customForkedScope = customScope?.clone();
-
   return withScope(customForkedScope, () => {
-    // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`
     const wrapper = getActiveSpanWrapper(customParentSpan);
-
     return wrapper(() => {
       const scope = getCurrentScope();
       const parentSpan = getParentSpan(scope, customParentSpan);
-
       const missingRequiredParent = options.onlyIfParent && !parentSpan;
-      const activeSpan = missingRequiredParent
-        ? new SentryNonRecordingSpan()
-        : createChildOrRootSpan({
-            parentSpan,
-            spanArguments,
-            forceTransaction,
-            scope,
-          });
-
+      const activeSpan = missingRequiredParent ? new SentryNonRecordingSpan() : createChildOrRootSpan({
+        parentSpan,
+        spanArguments,
+        forceTransaction,
+        scope
+      });
       if (missingRequiredParent) {
-        getClient()?.recordDroppedEvent('no_parent_span', 'span');
+        getClient()?.recordDroppedEvent("no_parent_span", "span");
       }
-
-      // We don't set ignored child spans onto the scope because there likely is an active,
-      // unignored span on the scope already.
       if (!_isIgnoredSpan(activeSpan) || !parentSpan) {
         _setSpanForScope(scope, activeSpan);
       }
-
       return handleCallbackErrors(
         // We pass the `finish` function to the callback, so the user can finish the span manually
         // this is mainly here for historic purposes because previously, we instructed users to call
@@ -154,458 +99,297 @@ function startSpanManual(options, callback) {
         // or `finish` has the same effect and we simply leave it here to avoid breaking user code.
         () => callback(activeSpan, () => activeSpan.end()),
         () => {
-          // Only update the span status if it hasn't been changed yet, and the span is not yet finished
           const { status } = spanToJSON(activeSpan);
-          if (activeSpan.isRecording() && (!status || status === 'ok')) {
-            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
+          if (activeSpan.isRecording() && (!status || status === "ok")) {
+            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
           }
-        },
+        }
       );
     });
   });
 }
-
-/**
- * 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.getActiveSpan()`.
- *
- * If you want to create a span that is set as active, use {@link startSpan}.
- *
- * 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.
- */
 function startInactiveSpan(options) {
   const acs = getAcs();
   if (acs.startInactiveSpan) {
     return acs.startInactiveSpan(options);
   }
-
   const spanArguments = parseSentrySpanArguments(options);
   const { forceTransaction, parentSpan: customParentSpan } = options;
-
-  // If `options.scope` is defined, we use this as as a wrapper,
-  // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`
-  const wrapper = options.scope
-    ? (callback) => withScope(options.scope, callback)
-    : customParentSpan !== undefined
-      ? (callback) => withActiveSpan(customParentSpan, callback)
-      : (callback) => callback();
-
+  const wrapper = options.scope ? (callback) => withScope(options.scope, callback) : customParentSpan !== void 0 ? (callback) => withActiveSpan(customParentSpan, callback) : (callback) => callback();
   return wrapper(() => {
     const scope = getCurrentScope();
     const parentSpan = getParentSpan(scope, customParentSpan);
     const client = getClient();
-
     const missingRequiredParent = options.onlyIfParent && !parentSpan;
-
     if (missingRequiredParent) {
-      client?.recordDroppedEvent('no_parent_span', 'span');
+      client?.recordDroppedEvent("no_parent_span", "span");
       return new SentryNonRecordingSpan();
     }
-
     return createChildOrRootSpan({
       parentSpan,
       spanArguments,
       forceTransaction,
-      scope,
+      scope
     });
   });
 }
-
-/**
- * Continue a trace from `sentry-trace` and `baggage` values.
- * These values can be obtained from incoming request headers, or in the browser from `<meta name="sentry-trace">`
- * and `<meta name="baggage">` HTML tags.
- *
- * Spans started with `startSpan`, `startSpanManual` and `startInactiveSpan`, within the callback will automatically
- * be attached to the incoming trace.
- */
-const continueTrace = (
-  options
-
-,
-  callback,
-) => {
+const continueTrace = (options, callback) => {
   const carrier = getMainCarrier();
   const acs = getAsyncContextStrategy(carrier);
   if (acs.continueTrace) {
     return acs.continueTrace(options, callback);
   }
-
   const { sentryTrace, baggage } = options;
-
   const client = getClient();
   const incomingDsc = baggageHeaderToDynamicSamplingContext(baggage);
   if (client && !shouldContinueTrace(client, incomingDsc?.org_id)) {
     return startNewTrace(callback);
   }
-
-  return withScope(scope => {
+  return withScope((scope) => {
     const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);
     scope.setPropagationContext(propagationContext);
-    _setSpanForScope(scope, undefined);
+    _setSpanForScope(scope, void 0);
     return callback();
   });
 };
-
-/**
- * Forks the current scope and sets the provided span as active span in the context of the provided callback. Can be
- * passed `null` to start an entirely new span tree.
- *
- * @param span Spans started in the context of the provided callback will be children of this span. If `null` is passed,
- * spans started within the callback will not be attached to a parent span.
- * @param callback Execution context in which the provided span will be active. Is passed the newly forked scope.
- * @returns the value returned from the provided callback function.
- */
 function withActiveSpan(span, callback) {
   const acs = getAcs();
   if (acs.withActiveSpan) {
     return acs.withActiveSpan(span, callback);
   }
-
-  return withScope(scope => {
-    _setSpanForScope(scope, span || undefined);
+  return withScope((scope) => {
+    _setSpanForScope(scope, span || void 0);
     return callback(scope);
   });
 }
-
-/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */
 function suppressTracing(callback) {
   const acs = getAcs();
-
   if (acs.suppressTracing) {
     return acs.suppressTracing(callback);
   }
-
-  return withScope(scope => {
-    // Note: We do not wait for the callback to finish before we reset the metadata
-    // the reason for this is that otherwise, in the browser this can lead to very weird behavior
-    // as there is only a single top scope, if the callback takes longer to finish,
-    // other, unrelated spans may also be suppressed, which we do not want
-    // so instead, we only suppress tracing synchronoysly in the browser
+  return withScope((scope) => {
     scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });
     const res = callback();
-    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: undefined });
+    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: void 0 });
     return res;
   });
 }
-
-/**
- * Starts a new trace for the duration of the provided callback. Spans started within the
- * callback will be part of the new trace instead of a potentially previously started trace.
- *
- * Important: Only use this function if you want to override the default trace lifetime and
- * propagation mechanism of the SDK for the duration and scope of the provided callback.
- * The newly created trace will also be the root of a new distributed trace, for example if
- * you make http requests within the callback.
- * This function might be useful if the operation you want to instrument should not be part
- * of a potentially ongoing trace.
- *
- * Default behavior:
- * - Server-side: A new trace is started for each incoming request.
- * - Browser: A new trace is started for each page our route. Navigating to a new route
- *            or page will automatically create a new trace.
- */
 function startNewTrace(callback) {
   const acs = getAcs();
   if (acs.startNewTrace) {
     return acs.startNewTrace(callback);
   }
-
-  return withScope(scope => {
+  return withScope((scope) => {
     scope.setPropagationContext({
       traceId: generateTraceId(),
-      sampleRand: safeMathRandom(),
+      sampleRand: safeMathRandom()
     });
     DEBUG_BUILD && debug.log(`Starting a new trace with id ${scope.getPropagationContext().traceId}`);
     return withActiveSpan(null, callback);
   });
 }
-
 function createChildOrRootSpan({
   parentSpan,
   spanArguments,
   forceTransaction,
-  scope,
-}
-
-) {
+  scope
+}) {
   if (!hasSpansEnabled()) {
-    const span = new SentryNonRecordingSpan();
-
-    // If this is a root span, we ensure to freeze a DSC
-    // So we can have at least partial data here
+    const span2 = new SentryNonRecordingSpan();
     if (forceTransaction || !parentSpan) {
       const dsc = {
-        sampled: 'false',
-        sample_rate: '0',
+        sampled: "false",
+        sample_rate: "0",
         transaction: spanArguments.name,
-        ...getDynamicSamplingContextFromSpan(span),
-      } ;
-      freezeDscOnSpan(span, dsc);
+        ...getDynamicSamplingContextFromSpan(span2)
+      };
+      freezeDscOnSpan(span2, dsc);
     }
-
-    return span;
+    return span2;
   }
-
   const client = getClient();
   if (_shouldIgnoreStreamedSpan(client, spanArguments)) {
     if (!_isTracingSuppressed(scope)) {
-      // if tracing is actively suppressed (Sentry.suppressTracing(...)),
-      // we don't want to record a client outcome for the ignored span
-      client?.recordDroppedEvent('ignored', 'span');
+      client?.recordDroppedEvent("ignored", "span");
     }
-
     return new SentryNonRecordingSpan({
-      dropReason: 'ignored',
-      traceId: parentSpan?.spanContext().traceId ?? scope.getPropagationContext().traceId,
+      dropReason: "ignored",
+      traceId: parentSpan?.spanContext().traceId ?? scope.getPropagationContext().traceId
     });
   }
-
   const isolationScope = getIsolationScope();
-
   let span;
   if (parentSpan && !forceTransaction) {
     span = _startChildSpan(parentSpan, scope, spanArguments);
     addChildSpanToSpan(parentSpan, span);
   } else if (parentSpan) {
-    // If we forced a transaction but have a parent span, make sure to continue from the parent span, not the scope
     const dsc = getDynamicSamplingContextFromSpan(parentSpan);
     const { traceId, spanId: parentSpanId } = parentSpan.spanContext();
     const parentSampled = spanIsSampled(parentSpan);
-
     span = _startRootSpan(
       {
         traceId,
         parentSpanId,
-        ...spanArguments,
+        ...spanArguments
       },
       scope,
-      parentSampled,
+      parentSampled
     );
-
     freezeDscOnSpan(span, dsc);
   } else {
     const {
       traceId,
       dsc,
       parentSpanId,
-      sampled: parentSampled,
+      sampled: parentSampled
     } = {
       ...isolationScope.getPropagationContext(),
-      ...scope.getPropagationContext(),
+      ...scope.getPropagationContext()
     };
-
     span = _startRootSpan(
       {
         traceId,
         parentSpanId,
-        ...spanArguments,
+        ...spanArguments
       },
       scope,
-      parentSampled,
+      parentSampled
     );
-
     if (dsc) {
       freezeDscOnSpan(span, dsc);
     }
   }
-
   logSpanStart(span);
-
   setCapturedScopesOnSpan(span, scope, isolationScope);
-
   return span;
 }
-
-/**
- * This converts StartSpanOptions to SentrySpanArguments.
- * For the most part (for now) we accept the same options,
- * but some of them need to be transformed.
- */
 function parseSentrySpanArguments(options) {
   const exp = options.experimental || {};
   const initialCtx = {
     isStandalone: exp.standalone,
-    ...options,
+    ...options
   };
-
   if (options.startTime) {
     const ctx = { ...initialCtx };
     ctx.startTimestamp = spanTimeInputToSeconds(options.startTime);
     delete ctx.startTime;
     return ctx;
   }
-
   return initialCtx;
 }
-
 function getAcs() {
   const carrier = getMainCarrier();
   return getAsyncContextStrategy(carrier);
 }
-
 function _startRootSpan(spanArguments, scope, parentSampled) {
   const client = getClient();
   const options = client?.getOptions() || {};
-
-  const { name = '' } = spanArguments;
-
+  const { name = "" } = spanArguments;
   const mutableSpanSamplingData = { spanAttributes: { ...spanArguments.attributes }, spanName: name, parentSampled };
-
-  // we don't care about the decision for the moment; this is just a placeholder
-  client?.emit('beforeSampling', mutableSpanSamplingData, { decision: false });
-
-  // If hook consumers override the parentSampled flag, we will use that value instead of the actual one
+  client?.emit("beforeSampling", mutableSpanSamplingData, { decision: false });
   const finalParentSampled = mutableSpanSamplingData.parentSampled ?? parentSampled;
   const finalAttributes = mutableSpanSamplingData.spanAttributes;
-
   const currentPropagationContext = scope.getPropagationContext();
   const isTracingSuppressed = _isTracingSuppressed(scope);
-
-  const [sampled, sampleRate, localSampleRateWasApplied] = isTracingSuppressed
-    ? [false]
-    : sampleSpan(
-        options,
-        {
-          name,
-          parentSampled: finalParentSampled,
-          attributes: finalAttributes,
-          parentSampleRate: parseSampleRate(currentPropagationContext.dsc?.sample_rate),
-        },
-        currentPropagationContext.sampleRand,
-      );
-
+  const [sampled, sampleRate, localSampleRateWasApplied] = isTracingSuppressed ? [false] : sampleSpan(
+    options,
+    {
+      name,
+      parentSampled: finalParentSampled,
+      attributes: finalAttributes,
+      parentSampleRate: parseSampleRate(currentPropagationContext.dsc?.sample_rate)
+    },
+    currentPropagationContext.sampleRand
+  );
   const rootSpan = new SentrySpan({
     ...spanArguments,
     attributes: {
-      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]:
-        sampleRate !== undefined && localSampleRateWasApplied ? sampleRate : undefined,
-      ...finalAttributes,
+      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "custom",
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: sampleRate !== void 0 && localSampleRateWasApplied ? sampleRate : void 0,
+      ...finalAttributes
     },
-    sampled,
+    sampled
   });
-
   if (!sampled && client && !isTracingSuppressed) {
-    DEBUG_BUILD && debug.log('[Tracing] Discarding root span because its trace was not chosen to be sampled.');
-    client.recordDroppedEvent('sample_rate', hasSpanStreamingEnabled(client) ? 'span' : 'transaction');
+    DEBUG_BUILD && debug.log("[Tracing] Discarding root span because its trace was not chosen to be sampled.");
+    client.recordDroppedEvent("sample_rate", hasSpanStreamingEnabled(client) ? "span" : "transaction");
   }
-
   if (client) {
-    client.emit('spanStart', rootSpan);
+    client.emit("spanStart", rootSpan);
   }
-
   return rootSpan;
 }
-
-/**
- * Creates a new `Span` while setting the current `Span.id` as `parentSpanId`.
- * This inherits the sampling decision from the parent span.
- */
 function _startChildSpan(parentSpan, scope, spanArguments) {
   const { spanId, traceId } = parentSpan.spanContext();
   const isTracingSuppressed = _isTracingSuppressed(scope);
   const sampled = isTracingSuppressed ? false : spanIsSampled(parentSpan);
-
-  const childSpan = sampled
-    ? new SentrySpan({
-        ...spanArguments,
-        parentSpanId: spanId,
-        traceId,
-        sampled,
-      })
-    : new SentryNonRecordingSpan({ traceId });
-
+  const childSpan = sampled ? new SentrySpan({
+    ...spanArguments,
+    parentSpanId: spanId,
+    traceId,
+    sampled
+  }) : new SentryNonRecordingSpan({ traceId });
   addChildSpanToSpan(parentSpan, childSpan);
-
   const client = getClient();
-
   if (!client) {
     return childSpan;
   }
-
   if (hasSpanStreamingEnabled(client) && childSpan instanceof SentryNonRecordingSpan) {
     if (parentSpan instanceof SentryNonRecordingSpan && parentSpan.dropReason) {
-      // We land here if the parent span was a segment span that was ignored (`ignoreSpans`).
-      // In this case, the child was also ignored (see `sampled` above) but we need to
-      // record a client outcome for the child.
       childSpan.dropReason = parentSpan.dropReason;
-      client.recordDroppedEvent(parentSpan.dropReason, 'span');
+      client.recordDroppedEvent(parentSpan.dropReason, "span");
     } else if (!isTracingSuppressed) {
-      // Otherwise, the child is not sampled due to sampling of the parent span,
-      // hence we record a sample_rate client outcome for the child.
-      childSpan.dropReason = 'sample_rate';
-      client.recordDroppedEvent('sample_rate', 'span');
+      childSpan.dropReason = "sample_rate";
+      client.recordDroppedEvent("sample_rate", "span");
     }
   }
-
-  client.emit('spanStart', childSpan);
-  // If it has an endTimestamp, it's already ended
+  client.emit("spanStart", childSpan);
   if (spanArguments.endTimestamp) {
-    client.emit('spanEnd', childSpan);
-    client.emit('afterSpanEnd', childSpan);
+    client.emit("spanEnd", childSpan);
+    client.emit("afterSpanEnd", childSpan);
   }
-
   return childSpan;
 }
-
 function getParentSpan(scope, customParentSpan) {
-  // always use the passed in span directly
   if (customParentSpan) {
-    return customParentSpan ;
+    return customParentSpan;
   }
-
-  // This is different from `undefined` as it means the user explicitly wants no parent span
   if (customParentSpan === null) {
-    return undefined;
+    return void 0;
   }
-
-  const span = _getSpanForScope(scope) ;
-
+  const span = _getSpanForScope(scope);
   if (!span) {
-    return undefined;
+    return void 0;
   }
-
   const client = getClient();
   const options = client ? client.getOptions() : {};
   if (options.parentSpanIsAlwaysRootSpan) {
-    return getRootSpan(span) ;
+    return getRootSpan(span);
   }
-
   return span;
 }
-
 function getActiveSpanWrapper(parentSpan) {
-  return parentSpan !== undefined
-    ? (callback) => {
-        return withActiveSpan(parentSpan, callback);
-      }
-    : (callback) => callback();
+  return parentSpan !== void 0 ? (callback) => {
+    return withActiveSpan(parentSpan, callback);
+  } : (callback) => callback();
 }
-
-/* Checks if `ignoreSpans` applies (extracted for bundle size)*/
 function _shouldIgnoreStreamedSpan(client, spanArguments) {
   const ignoreSpans = client?.getOptions().ignoreSpans;
-
   if (!client || !hasSpanStreamingEnabled(client) || !ignoreSpans?.length) {
     return false;
   }
-
   return shouldIgnoreSpan(
     {
-      description: spanArguments.name || '',
+      description: spanArguments.name || "",
       op: spanArguments.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] || spanArguments.op,
-      attributes: spanArguments.attributes,
+      attributes: spanArguments.attributes
     },
-    ignoreSpans,
+    ignoreSpans
   );
 }
-
 function _isIgnoredSpan(span) {
-  return span instanceof SentryNonRecordingSpan && span.dropReason === 'ignored';
+  return span instanceof SentryNonRecordingSpan && span.dropReason === "ignored";
 }
-
 function _isTracingSuppressed(scope) {
   return scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] === true;
 }