RUM-15138: Read session sample rate from span tags instead of provider-based plumbing

Replace the multi-layer sessionSampleRateProvider chain (FeatureContextUpdateReceiver → TracingFeature → AtomicReference → DeterministicTraceSampler) with direct reads from the session_sample_rate span tag that RumContextPropagator already writes before sampling runs.

This eliminates SessionSampleRateRegistrationEvent, FeatureContextUpdateReceiver on TracingFeature, AtomicReference caching, and sendEvent cross-module wiring — resolving locking concerns, timing races, and misleading defaults flagged during review.

getSampleRate() (no-arg) now returns the raw configured trace rate. Per-span rebasing lives in sample(item) and the deprecated getSampleRate(item), accessed through the effectiveSampleRate() casting bridge until V4 allows replacing the Sampler<DatadogSpan> interface.

Author: hamorillo

features/dd-sdk-android-trace/api/apiSurface

@@ -22,7 +22,6 @@ open class com.datadog.android.trace.DeterministicTraceSampler : com.datadog.and
   constructor(() -> Float)
   constructor(Float)
   constructor(Double)
-  override fun getSampleRate(): Float
   override fun sample(com.datadog.android.trace.api.span.DatadogSpan): Boolean
   DEPRECATED fun getSampleRate(com.datadog.android.trace.api.span.DatadogSpan): Float
 annotation com.datadog.android.trace.ExperimentalTraceApi

features/dd-sdk-android-trace/api/dd-sdk-android-trace.api

@@ -34,7 +34,6 @@ public class com/datadog/android/trace/DeterministicTraceSampler : com/datadog/a
 	public fun <init> (D)V
 	public fun <init> (F)V
 	public fun <init> (Lkotlin/jvm/functions/Function0;)V
-	public fun getSampleRate ()Ljava/lang/Float;
 	public final fun getSampleRate (Lcom/datadog/android/trace/api/span/DatadogSpan;)F
 	public fun sample (Lcom/datadog/android/trace/api/span/DatadogSpan;)Z
 	public synthetic fun sample (Ljava/lang/Object;)Z

features/dd-sdk-android-trace/src/main/kotlin/com/datadog/android/trace/ApmNetworkInstrumentationConfiguration.kt

@@ -13,9 +13,7 @@ import com.datadog.android.core.sampling.Sampler
 import com.datadog.android.trace.api.span.DatadogSpan
 import com.datadog.android.trace.api.tracer.DatadogTracer
 import com.datadog.android.trace.internal.ApmNetworkInstrumentation
-import com.datadog.android.trace.internal.TracingFeature
 import com.datadog.android.trace.internal.net.TracerProvider
-import java.util.concurrent.atomic.AtomicReference
 
 /**
  * Configuration for APM distributed tracing of network requests.
@@ -251,12 +249,8 @@ class ApmNetworkInstrumentationConfiguration internal constructor(
 
             val tracerProvider = TracerProvider(localTracerFactory, globalTracerProvider)
 
-            @Suppress("UnsafeThirdPartyFunctionCall") // AtomicReference initialized with non-null Float constant
-            val cachedSessionSampleRate = AtomicReference(TracingFeature.NO_SESSION_REBASING_RATE)
-            val sessionSampleRateRef: AtomicReference<Float>? =
-                if (customTraceSampler == null) cachedSessionSampleRate else null
             val effectiveSampler = customTraceSampler
-                ?: DeterministicTraceSampler(traceSampleRate) { cachedSessionSampleRate.get() }
+                ?: DeterministicTraceSampler(traceSampleRate)
 
             return ApmNetworkInstrumentation(
                 canSendSpan = !headerPropagationOnly,
@@ -269,8 +263,7 @@ class ApmNetworkInstrumentationConfiguration internal constructor(
                 networkingLibraryName = instrumentationName,
                 tracedRequestListener = tracedRequestListener,
                 redacted404ResourceName = redacted404ResourceName,
-                localFirstPartyHostHeaderTypeResolver = localFirstPartyHostHeaderTypeResolver,
-                sessionSampleRateRef = sessionSampleRateRef
+                localFirstPartyHostHeaderTypeResolver = localFirstPartyHostHeaderTypeResolver
             )
         }
 

features/dd-sdk-android-trace/src/main/kotlin/com/datadog/android/trace/DeterministicTraceSampler.kt

@@ -14,41 +14,31 @@ import com.datadog.android.trace.api.span.DatadogSpan
 import com.datadog.android.trace.internal.net.SpanSamplingIdProvider
 
 /**
- * A [com.datadog.android.core.sampling.DeterministicSampler] using the TraceID of a Span to compute the sampling decision.
+ * A [com.datadog.android.core.sampling.DeterministicSampler] using the TraceID of a Span to compute the sampling
+ * decision.
  *
- * The sampling threshold is automatically rebased against the RUM session sample rate when it is
- * available so that the combined effective sampling probability reflects:
+ * When a span carries a RUM session context (written by
+ * [com.datadog.android.trace.internal.RumContextPropagator]), the sampling threshold is
+ * automatically rebased against the RUM session sample rate so that the combined effective
+ * sampling probability reflects:
  *
  * ```
- * rebasedTraceSampleRate = sessionSampleRate * traceSampleRate / 100
+ * effectiveRate = traceSampleRate * sessionSampleRate / 100
  * ```
  *
- * Note: overriding [getSampleRate] is not a supported extension point for per-span sampling
- * behavior.
+ * Spans without a `session_sample_rate` tag are sampled at the raw trace sample rate.
  *
  * @param sampleRateProvider Provider for the trace sample rate. Called each time the sampling
  * decision needs to be made. Values must be in the range [0;100].
- * @param sessionSampleRateProvider Provider for the RUM session sample rate used to rebase the
- * trace sample rate. Defaults to 100 (no rebasing).
  */
 // TODO RUM-13454 -> Make this class internal in V4 (RUM-15590)
-open class DeterministicTraceSampler private constructor(
-    private val sampleRateProvider: () -> Float,
-    private val sessionSampleRateProvider: () -> Float
+open class DeterministicTraceSampler(
+    sampleRateProvider: () -> Float
 ) : DeterministicSampler<DatadogSpan>(
     SpanSamplingIdProvider::provideId,
     sampleRateProvider
 ) {
 
-    /**
-     * Creates a new instance of [DeterministicTraceSampler] with the given sample rate provider.
-     *
-     * @param sampleRateProvider Provider for the sample rate value.
-     */
-    constructor(
-        sampleRateProvider: () -> Float
-    ) : this(sampleRateProvider, { DeterministicSampler.SAMPLE_ALL_RATE })
-
     /**
      * Creates a new instance of [DeterministicTraceSampler] with the given sample rate.
      *
@@ -67,77 +57,47 @@ open class DeterministicTraceSampler private constructor(
         @FloatRange(from = 0.0, to = 100.0) sampleRate: Double
     ) : this(sampleRate.toFloat())
 
-    /**
-     * Internal constructor used by [com.datadog.android.trace.ApmNetworkInstrumentationConfiguration]
-     * to wire the RUM session sample rate provider at instrumentation setup time.
-     */
-    internal constructor(
-        @FloatRange(from = 0.0, to = 100.0) sampleRate: Float,
-        sessionSampleRateProvider: () -> Float
-    ) : this({ sampleRate }, sessionSampleRateProvider)
-
-    /**
-     * Returns the effective sample rate, rebased against the RUM session sample rate when it is
-     * available:
-     *
-     * ```
-     * effectiveRate = traceSampleRate * sessionSampleRate / 100
-     * ```
-     *
-     * Falls back to the raw trace sample rate when no session sample rate is available
-     * (i.e. [sessionSampleRateProvider] returns 100).
-     */
-    override fun getSampleRate(): Float {
-        val traceSampleRate = super.getSampleRate()
-        val sessionSampleRate = sessionSampleRateProvider()
-        return if (sessionSampleRate >= 0f && sessionSampleRate < DeterministicSampler.SAMPLE_ALL_RATE) {
-            val rebased = traceSampleRate * sessionSampleRate / DeterministicSampler.SAMPLE_ALL_RATE
-            rebased.coerceAtMost(DeterministicSampler.SAMPLE_ALL_RATE)
-        } else {
-            traceSampleRate
-        }
-    }
-
     /** @inheritDoc */
     // TODO RUM-13454 -> Remove the @Suppress when getSampleRate(DatadogSpan) is removed in V4 (RUM-15590)
     @Suppress("DEPRECATION")
     override fun sample(item: DatadogSpan): Boolean =
         computeSamplingDecision(getSampleRate(item), SpanSamplingIdProvider.provideId(item))
 
     /**
-     * Returns the effective sample rate for [item], applying cross-product rebasing when a RUM
-     * session rate is available.
+     * Returns the effective sample rate for [item], applying cross-product rebasing when the
+     * span carries a `session_sample_rate` tag (written by
+     * [com.datadog.android.trace.internal.RumContextPropagator]).
      *
-     * When this sampler was created via [ApmNetworkInstrumentationConfiguration] the session rate
-     * is read from the injected [sessionSampleRateProvider]. For samplers created via the public
-     * constructors (no provider) the rate is read from the `session_sample_rate` span tag written
-     * by [com.datadog.android.trace.internal.RumContextPropagator], providing compatibility with
-     * [com.datadog.android.okhttp.trace.TracingInterceptor] and related legacy integrations.
+     * When no tag is present the raw trace sample rate is returned unchanged.
      */
     // TODO RUM-13454 -> Remove this in V4 when deprecating legacy paths (RUM-15590)
     @Deprecated(
-        "Use ApmNetworkInstrumentationConfiguration for session-aware sampling. Will be removed in v4.",
+        "Will be removed in v4.",
         level = DeprecationLevel.WARNING
     )
     fun getSampleRate(item: DatadogSpan): Float {
-        // Compatibility path for integrations creating this sampler via public constructors
-        // (no sessionSampleRateProvider). In that case the session sample rate is propagated on
-        // the span context as `session_sample_rate` and must be used for rebasing.
-        val providerRate = sessionSampleRateProvider()
-        val providerRateIsValid = providerRate >= 0f && providerRate < DeterministicSampler.SAMPLE_ALL_RATE
-        val sessionSampleRate = when {
-            providerRateIsValid -> providerRate
-            else -> (item.context().tags[LogAttributes.RUM_SESSION_SAMPLE_RATE] as? Number)?.toFloat()
-        }
+        return resolveEffectiveSampleRate(item)
+    }
 
+    // region private
+
+    private fun resolveEffectiveSampleRate(item: DatadogSpan): Float {
+        val traceSampleRate = super.getSampleRate()
+        val sessionSampleRate = resolveSessionSampleRate(item)
         return if (sessionSampleRate != null &&
             sessionSampleRate >= 0f &&
             sessionSampleRate < DeterministicSampler.SAMPLE_ALL_RATE
         ) {
-            val rebased = super.getSampleRate() * sessionSampleRate / DeterministicSampler.SAMPLE_ALL_RATE
-            if (rebased > DeterministicSampler.SAMPLE_ALL_RATE) DeterministicSampler.SAMPLE_ALL_RATE else rebased
+            (traceSampleRate * sessionSampleRate / DeterministicSampler.SAMPLE_ALL_RATE)
+                .coerceAtMost(DeterministicSampler.SAMPLE_ALL_RATE)
         } else {
-            super.getSampleRate()
+            traceSampleRate
         }
     }
+
+    private fun resolveSessionSampleRate(item: DatadogSpan): Float? {
+        return (item.context().tags[LogAttributes.RUM_SESSION_SAMPLE_RATE] as? Number)?.toFloat()
+    }
+
+    // endregion
 }

features/dd-sdk-android-trace/src/main/kotlin/com/datadog/android/trace/internal/ApmNetworkInstrumentation.kt

@@ -8,7 +8,6 @@ package com.datadog.android.trace.internal
 
 import com.datadog.android.api.InternalLogger
 import com.datadog.android.api.SdkCore
-import com.datadog.android.api.feature.Feature
 import com.datadog.android.api.instrumentation.network.HttpRequestInfo
 import com.datadog.android.api.instrumentation.network.HttpRequestInfoBuilder
 import com.datadog.android.api.instrumentation.network.HttpResponseInfo
@@ -38,7 +37,6 @@ import com.datadog.android.trace.internal.net.finishRumAware
 import com.datadog.android.trace.internal.net.sample
 import java.net.HttpURLConnection
 import java.util.Locale
-import java.util.concurrent.atomic.AtomicReference
 
 /**
  * For internal usage only.
@@ -59,11 +57,6 @@ import java.util.concurrent.atomic.AtomicReference
  * @param localFirstPartyHostHeaderTypeResolver resolver for determining header types for first-party hosts.
  * @param networkingLibraryName the name identifying the network instrumentation (e.g., "OkHttp", "Cronet").
  * @param networkTracingScope Tracing scope for the instrumentation. See [ApmNetworkTracingScope] enum for more details.
- * @param sessionSampleRateRef optional [AtomicReference] that [TracingFeature] will keep
- *        up-to-date with the latest RUM session sample rate. When the SDK core resolves,
- *        this ref is sent to [TracingFeature] via `sendEvent` so that it is updated whenever
- *        the RUM context changes. The corresponding [DeterministicTraceSampler] reads from
- *        this ref on every request (volatile read, no locking).
  */
 @Suppress("LongParameterList")
 @InternalApi
@@ -78,8 +71,7 @@ class ApmNetworkInstrumentation internal constructor(
     internal val tracedRequestListener: NetworkTracedRequestListener,
     internal val localFirstPartyHostHeaderTypeResolver: DefaultFirstPartyHostHeaderTypeResolver,
     private val networkingLibraryName: String,
-    val networkTracingScope: ApmNetworkTracingScope = ApmNetworkTracingScope.ALL,
-    internal val sessionSampleRateRef: AtomicReference<Float>? = null
+    val networkTracingScope: ApmNetworkTracingScope = ApmNetworkTracingScope.ALL
 ) {
     private val rumContextPropagator = RumContextPropagator { internalSdkCore }
 
@@ -98,10 +90,6 @@ class ApmNetworkInstrumentation internal constructor(
                 WARNING_TRACING_NO_HOSTS.format(Locale.US, networkingLibraryName)
             }
         }
-        sessionSampleRateRef?.let { ref ->
-            sdkCore.getFeature(Feature.TRACING_FEATURE_NAME)
-                ?.sendEvent(SessionSampleRateRegistrationEvent(ref))
-        }
     }
 
     /** The sample rate used by the trace sampler, or null if unavailable. */

features/dd-sdk-android-trace/src/main/kotlin/com/datadog/android/trace/internal/SessionSampleRateRegistrationEvent.kt

@@ -8,13 +8,10 @@ package com.datadog.android.trace.internal
 
 import android.content.Context
 import com.datadog.android.api.feature.Feature
-import com.datadog.android.api.feature.FeatureContextUpdateReceiver
-import com.datadog.android.api.feature.FeatureEventReceiver
 import com.datadog.android.api.feature.FeatureSdkCore
 import com.datadog.android.api.feature.StorageBackedFeature
 import com.datadog.android.api.net.RequestFactory
 import com.datadog.android.api.storage.FeatureStorageConfiguration
-import com.datadog.android.log.LogAttributes
 import com.datadog.android.trace.InternalCoreWriterProvider
 import com.datadog.android.trace.event.SpanEventMapper
 import com.datadog.android.trace.internal.data.CoreTraceWriter
@@ -25,7 +22,6 @@ import com.datadog.android.trace.internal.net.TracesRequestFactory
 import com.datadog.trace.common.writer.NoOpWriter
 import com.datadog.trace.common.writer.Writer
 import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicReference
 
 /**
  * Tracing feature class, which needs to be registered with Datadog SDK instance.
@@ -35,23 +31,17 @@ internal class TracingFeature(
     customEndpointUrl: String?,
     internal val spanEventMapper: SpanEventMapper,
     internal val networkInfoEnabled: Boolean
-) : InternalCoreWriterProvider, StorageBackedFeature, FeatureContextUpdateReceiver, FeatureEventReceiver {
+) : InternalCoreWriterProvider, StorageBackedFeature {
 
     internal var coreTracerDataWriter: Writer = NoOpWriter()
     internal val initialized = AtomicBoolean(false)
 
-    internal val internalSessionSampleRate = AtomicReference(NO_SESSION_REBASING_RATE)
-    private val sessionSampleRateRefs = mutableSetOf<AtomicReference<Float>>()
-    internal val registrationLock = Any()
-
     // region Feature
 
     override val name: String = Feature.TRACING_FEATURE_NAME
 
     override fun onInitialize(appContext: Context) {
         coreTracerDataWriter = createDataWriter(sdkCore)
-        sdkCore.setContextUpdateReceiver(this)
-        sdkCore.setEventReceiver(name, this)
         initialized.set(true)
     }
 
@@ -66,54 +56,17 @@ internal class TracingFeature(
         FeatureStorageConfiguration.DEFAULT
 
     override fun onStop() {
-        sdkCore.removeContextUpdateReceiver(this)
-        sdkCore.removeEventReceiver(name)
-        resetSessionSampleRateTracking()
         initialized.set(false)
     }
 
     // endregion
 
-    // region FeatureContextUpdateReceiver
-
-    override fun onContextUpdate(featureName: String, context: Map<String, Any?>) {
-        if (featureName == Feature.RUM_FEATURE_NAME) {
-            val rate = resolveSessionSampleRate(context[LogAttributes.RUM_SESSION_SAMPLE_RATE])
-            synchronized(registrationLock) {
-                internalSessionSampleRate.set(rate)
-                sessionSampleRateRefs.forEach { it.set(rate) }
-            }
-        }
-    }
-
-    // endregion
-
-    // region FeatureEventReceiver
-
-    override fun onReceive(event: Any) {
-        if (event is SessionSampleRateRegistrationEvent) {
-            synchronized(registrationLock) {
-                sessionSampleRateRefs.add(event.ref)
-                event.ref.set(internalSessionSampleRate.get())
-            }
-        }
-    }
-
-    // endregion
-
     // region InternalCoreWriterProvider
 
     override fun getCoreTracerWriter() = DatadogSpanWriterWrapper(coreTracerDataWriter)
 
     // endregion
 
-    private fun resetSessionSampleRateTracking() {
-        synchronized(registrationLock) {
-            sessionSampleRateRefs.clear()
-            internalSessionSampleRate.set(NO_SESSION_REBASING_RATE)
-        }
-    }
-
     private fun createDataWriter(sdkCore: FeatureSdkCore): Writer {
         val internalLogger = sdkCore.internalLogger
         return CoreTraceWriter(
@@ -124,15 +77,4 @@ internal class TracingFeature(
             internalLogger = internalLogger
         )
     }
-
-    internal companion object {
-        // Sentinel value meaning "assume all RUM sessions are sampled" so that no session-based
-        // rebasing is applied until the RUM feature publishes its actual session sample rate.
-        // With this value the effective rate is: traceSampleRate * 100 / 100 = traceSampleRate.
-        internal const val NO_SESSION_REBASING_RATE: Float = 100f
-
-        private fun resolveSessionSampleRate(rawSessionSampleRate: Any?): Float {
-            return (rawSessionSampleRate as? Number)?.toFloat() ?: NO_SESSION_REBASING_RATE
-        }
-    }
 }