beep boop actually do what I am supposed to beep boop

Author: Luca Forstner

packages/core/src/semanticAttributes.ts

@@ -12,6 +12,11 @@ export const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = 'sentry.source';
  */
 export const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = 'sentry.sample_rate';
 
+/**
+ * Use this attribute on a root span to propagate the spans sample rate downstream as parent sample rate in the DSC, overriding anything that was previously set on the DSC.
+ */
+export const SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE = 'sentry.override_trace_sample_rate';
+
 /**
  * Use this attribute to represent the operation of a span.
  */

packages/core/src/tracing/dynamicSamplingContext.ts

@@ -2,7 +2,11 @@ import type { Client } from '../client';
 import { DEFAULT_ENVIRONMENT } from '../constants';
 import { getClient } from '../currentScopes';
 import type { Scope } from '../scope';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes';
+import {
+  SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+} from '../semanticAttributes';
 import type { DynamicSamplingContext, Span } from '../types-hoist';
 import {
   baggageHeaderToDynamicSamplingContext,
@@ -77,12 +81,14 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
   const rootSpan = getRootSpan(span);
   const rootSpanJson = spanToJSON(rootSpan);
   const rootSpanAttributes = rootSpanJson.data;
+  const shouldOverrideDscSampleRate = rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE];
   const maybeSampleRate = rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE];
 
   // The root span sample rate should always be applied to the DSC, even if the DSC is frozen.
   // This is so that the downstream traces/services can use parentSampleRate in their `tracesSampler` to make consistent sampling decisions across the entire trace.
   function applyRootSpanSampleRateToDsc(dsc: Partial<DynamicSamplingContext>): Partial<DynamicSamplingContext> {
-    if (maybeSampleRate != null) {
+    // Note: This is a `!= null` check meaning "nullish"
+    if (shouldOverrideDscSampleRate && maybeSampleRate != null) {
       dsc.sample_rate = `${maybeSampleRate}`;
     }
     return dsc;
@@ -108,6 +114,11 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
   // Else, we generate it from the span
   const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);
 
+  // Note: This is a `!= null` check meaning "nullish"
+  if (maybeSampleRate != null) {
+    dsc.sample_rate = `${maybeSampleRate}`;
+  }
+
   // We don't want to have a transaction name in the DSC if the source is "url" because URLs might contain PII
   const source = rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
 

packages/core/src/tracing/sampling.ts

@@ -15,24 +15,29 @@ export function sampleSpan(
   options: Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'>,
   samplingContext: SamplingContext,
   sampleRand: number,
-): [sampled: boolean, sampleRate?: number] {
+): [sampled: boolean, sampleRate?: number, shouldUpdateSampleRateOnDsc?: boolean] {
   // nothing to do if tracing is not enabled
   if (!hasTracingEnabled(options)) {
     return [false];
   }
 
+  let shouldUpdateSampleRateOnDsc = false;
+
   // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` nor `enableTracing` were defined, so one of these should
   // work; prefer the hook if so
   let sampleRate;
   if (typeof options.tracesSampler === 'function') {
     sampleRate = options.tracesSampler(samplingContext);
+    shouldUpdateSampleRateOnDsc = true;
   } else if (samplingContext.parentSampled !== undefined) {
     sampleRate = samplingContext.parentSampled;
   } else if (typeof options.tracesSampleRate !== 'undefined') {
     sampleRate = options.tracesSampleRate;
+    shouldUpdateSampleRateOnDsc = true;
   } else {
     // When `enableTracing === true`, we use a sample rate of 100%
     sampleRate = 1;
+    shouldUpdateSampleRateOnDsc = true;
   }
 
   // Since this is coming from the user (or from a function provided by the user), who knows what we might get.
@@ -54,7 +59,7 @@ export function sampleSpan(
             : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'
         }`,
       );
-    return [false, parsedSampleRate];
+    return [false, parsedSampleRate, shouldUpdateSampleRateOnDsc];
   }
 
   // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is
@@ -69,8 +74,8 @@ export function sampleSpan(
           sampleRate,
         )})`,
       );
-    return [false, parsedSampleRate];
+    return [false, parsedSampleRate, shouldUpdateSampleRateOnDsc];
   }
 
-  return [true, parsedSampleRate];
+  return [true, parsedSampleRate, shouldUpdateSampleRateOnDsc];
 }

packages/core/src/tracing/trace.ts

@@ -16,7 +16,11 @@ import { getClient, getCurrentScope, getIsolationScope, withScope } from '../cur
 import { getAsyncContextStrategy } from '../asyncContext';
 import { DEBUG_BUILD } from '../debug-build';
 import type { Scope } from '../scope';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes';
+import {
+  SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+} from '../semanticAttributes';
 import { logger } from '../utils-hoist/logger';
 import { generateTraceId } from '../utils-hoist/propagationContext';
 import { propagationContextFromHeaders } from '../utils-hoist/tracing';
@@ -407,7 +411,9 @@ function _startRootSpan(spanArguments: SentrySpanArguments, scope: Scope, parent
 
   const { name = '', attributes } = spanArguments;
   const currentPropagationContext = scope.getPropagationContext();
-  const [sampled, sampleRate] = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY]
+  const [sampled, sampleRate, shouldUpdateSampleRateOnDsc] = scope.getScopeData().sdkProcessingMetadata[
+    SUPPRESS_TRACING_KEY
+  ]
     ? [false]
     : sampleSpan(
         options,
@@ -436,6 +442,7 @@ function _startRootSpan(spanArguments: SentrySpanArguments, scope: Scope, parent
 
   if (sampleRate !== undefined) {
     rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);
+    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE, shouldUpdateSampleRateOnDsc);
   }
 
   if (client) {

packages/opentelemetry/src/sampler.ts

@@ -13,6 +13,7 @@ import {
 import type { Client, SpanAttributes } from '@sentry/core';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE,
   SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
   hasTracingEnabled,
   logger,
@@ -106,7 +107,7 @@ export class SentrySampler implements Sampler {
     // Non-root-spans simply inherit the sampling decision from their parent.
     if (isRootSpan) {
       const currentPropagationContext = scope?.getPropagationContext();
-      const [sampled, sampleRate] = sampleSpan(
+      const [sampled, sampleRate, shouldUpdateSampleRateOnDsc] = sampleSpan(
         options,
         {
           name: inferredSpanName,
@@ -120,6 +121,7 @@ export class SentrySampler implements Sampler {
 
       const attributes: Attributes = {
         [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: sampleRate,
+        [SEMANTIC_ATTRIBUTE_SENTRY_OVERRIDE_TRACE_SAMPLE_RATE]: shouldUpdateSampleRateOnDsc,
       };
 
       const method = `${maybeSpanHttpMethod}`.toUpperCase();