DataDog · ncreated · Oct 24, 2022 · Oct 19, 2022 · Oct 19, 2022 · Oct 20, 2022
@@ -1,5 +1,7 @@
 # Unreleased
 
+- [IMPROVEMENT] Send trace sample rate (`dd.rulePsr`) for APM's traffic ingestion control page. See [#1029][]
+
 # 1.12.1 / 18-10-2022
 
 - [IMPROVEMENT] Upgrade to PLCrashReporter 1.11.0 to fix Xcode 14 support.
@@ -402,6 +404,7 @@
 [@leffelmania]: https://github.com/LeffelMania
 [@simpleapp]: https://github.com/SimpleApp
 [@tsvetelinvladimirov]: https://github.com/TsvetelinVladimirov
+[#1029]: https://github.com/DataDog/dd-sdk-ios/issues/1029
 [@arnauddorgans]: https://github.com/arnauddorgans
 [@ben-yolabs]: https://github.com/ben-yolabs
 [@earltedly]: https://github.com/earltedly

@@ -113,4 +113,10 @@ internal struct CrossPlatformAttributes {
     /// and send it within the RUM resource, so the RUM backend can issue corresponding APM span on behalf of the mobile app.
     /// Expects `String` value.
     static let spanID = "_dd.span_id"
+
+    /// Trace sample rate applied to RUM resources created by cross platform SDK.
+    /// We send cross-platform SDK's sample rate within RUM resource in order to provide accurate visibility into what settings are
+    /// configured at the SDK level. This gets displayed on APM's traffic ingestion control page.
+    /// Expects `Double` value between `0.0` and `1.0`.
+    static let rulePSR = "_dd.rule_psr"
 }
@@ -80,7 +80,9 @@ internal struct FeaturesConfiguration {
         let instrumentTracing: Bool
         /// If the RUM instrumentation should be enabled.
         let instrumentRUM: Bool
-        // Tracing sampler
+        /// Tracing sampler to decide if trace should be generated for certain network request:
+        /// - if RUM instrumentation is enabled, it is used to sample traces generated by RUM BE,
+        /// - if RUM is disabled, it is used to sample traces generated by the SDK.
         let tracingSampler: Sampler
     }
 

@@ -10,14 +10,17 @@ internal typealias URLSessionRUMAttributesProvider = (URLRequest, URLResponse?,
 
 internal class URLSessionRUMResourcesHandler: URLSessionInterceptionHandler, RUMCommandPublisher {
     private let dateProvider: DateProvider
+    /// Tracing sampler used to sample traces generated by RUM BE.
+    let tracingSampler: Sampler
     /// Attributes-providing callback.
     /// It is configured by the user and should be used to associate additional RUM attributes with intercepted RUM Resource.
     let rumAttributesProvider: (URLSessionRUMAttributesProvider)?
 
     // MARK: - Initialization
 
-    init(dateProvider: DateProvider, rumAttributesProvider: (URLSessionRUMAttributesProvider)?) {
+    init(dateProvider: DateProvider, tracingSampler: Sampler, rumAttributesProvider: URLSessionRUMAttributesProvider?) {
         self.dateProvider = dateProvider
+        self.tracingSampler = tracingSampler
         self.rumAttributesProvider = rumAttributesProvider
     }
 
@@ -45,7 +48,8 @@ internal class URLSessionRUMResourcesHandler: URLSessionInterceptionHandler, RUM
                 spanContext: interception.spanContext.map {
                     .init(
                         traceID: String($0.traceID.rawValue),
-                        spanID: String($0.spanID.rawValue)
+                        spanID: String($0.spanID.rawValue),
+                        samplingRate: Double(tracingSampler.samplingRate) / 100.0
                     )
                 }
             )

@@ -146,8 +146,12 @@ internal protocol RUMResourceCommand: RUMCommand {
 /// Tracing information propagated by Tracing to the underlying `URLRequest`. It is passed to the RUM backend
 /// in order to create the APM span. The actual `Span` is not send by the SDK.
 internal struct RUMSpanContext {
+    /// The trace ID injected to `URLRequest` that issues RUM resource.
     let traceID: String
+    /// The span ID injected to `URLRequest` that issues RUM resource.
     let spanID: String
+    /// The sampling rate applied to the trace (a value between `0.0` and `1.0`).
+    let samplingRate: Double
 }
 
 internal struct RUMStartResourceCommand: RUMResourceCommand {

@@ -118,6 +118,7 @@ internal class RUMResourceScope: RUMScope {
         // Check trace attributes
         let traceId = (attributes.removeValue(forKey: CrossPlatformAttributes.traceID) as? String) ?? spanContext?.traceID
         let spanId = (attributes.removeValue(forKey: CrossPlatformAttributes.spanID) as? String) ?? spanContext?.spanID
+        let traceSamplingRate = (attributes.removeValue(forKey: CrossPlatformAttributes.rulePSR) as? Double) ?? spanContext?.samplingRate
 
         /// Metrics values take precedence over other values.
         if let metrics = resourceMetrics {
@@ -135,7 +136,7 @@ internal class RUMResourceScope: RUMScope {
             dd: .init(
                 browserSdkVersion: nil,
                 discarded: nil,
-                rulePsr: nil,
+                rulePsr: traceSamplingRate,
                 session: .init(plan: .plan1),
                 spanId: spanId,
                 traceId: traceId

@@ -9,7 +9,7 @@ import Foundation
 internal class URLSessionTracingHandler: URLSessionInterceptionHandler {
     /// Listening to app state changes and use it to report `foreground_duration`
     let appStateListener: AppStateListening
-    /// The Tracing sampler.
+    /// Tracing sampler used to sample traces generated by the SDK.
     let tracingSampler: Sampler
 
     init(appStateListener: AppStateListening, tracingSampler: Sampler) {

@@ -45,7 +45,7 @@ public class URLSessionInterceptor: URLSessionInterceptorType {
     /// Additional header injected to intercepted 1st party requests.
     /// Set to `x-datadog-origin: rum` if both RUM and Tracing instrumentations are enabled and `nil` in all other cases.
     internal let additionalHeadersForFirstPartyRequests: [String: String]?
-    /// Tracing sampler
+    /// Tracing sampler used to sample traces generated by the SDK or RUM BE.
     internal let tracingSampler: Sampler
 
     // MARK: - Initialization
@@ -60,6 +60,7 @@ public class URLSessionInterceptor: URLSessionInterceptorType {
         if configuration.instrumentRUM {
             handler = URLSessionRUMResourcesHandler(
                 dateProvider: dateProvider,
+                tracingSampler: configuration.tracingSampler,
                 rumAttributesProvider: configuration.rumAttributesProvider
             )
         } else {

@@ -134,6 +134,7 @@ class RUMResourcesScenarioTests: IntegrationTests, RUMCommonAsserts {
 
         XCTAssertNil(firstPartyResource1.dd.traceId, "`firstPartyGETResourceURL` should not be traced")
         XCTAssertNil(firstPartyResource1.dd.spanId, "`firstPartyGETResourceURL` should not be traced")
+        XCTAssertNil(firstPartyResource1.dd.rulePsr, "Not traced resource should not send sample rate")
 
         let firstPartyResource2 = try XCTUnwrap(
             session.viewVisits[0].resourceEvents.first { $0.resource.url == firstPartyPOSTResourceURL.absoluteString },
@@ -151,6 +152,8 @@ class RUMResourcesScenarioTests: IntegrationTests, RUMCommonAsserts {
             firstPartyPOSTRequestSpanID,
             "Tracing information should be propagated to `firstPartyPOSTResourceURL`"
         )
+        let firstPartyResource2SampleRate = try XCTUnwrap(firstPartyResource2.dd.rulePsr, "Traced resource should send sample rate")
+        XCTAssertTrue(isValid(sampleRate: firstPartyResource2SampleRate), "\(firstPartyResource2SampleRate) is not valid sample rate")
 
         let firstPartyResourceError1 = try XCTUnwrap(
             session.viewVisits[0].errorEvents.first { $0.error.resource?.url == firstPartyBadResourceURL.absoluteString },
@@ -172,6 +175,7 @@ class RUMResourcesScenarioTests: IntegrationTests, RUMCommonAsserts {
         XCTAssertGreaterThan(thirdPartyResource1.resource.duration, 0)
         XCTAssertNil(thirdPartyResource1.dd.traceId, "3rd party RUM Resources should not be traced")
         XCTAssertNil(thirdPartyResource1.dd.spanId, "3rd party RUM Resources should not be traced")
+        XCTAssertNil(thirdPartyResource1.dd.rulePsr, "Not traced resource should not send sample rate")
 
         let thirdPartyResource2 = try XCTUnwrap(
             session.viewVisits[1].resourceEvents.first { $0.resource.url == thirdPartyPOSTResourceURL.absoluteString },
@@ -181,6 +185,7 @@ class RUMResourcesScenarioTests: IntegrationTests, RUMCommonAsserts {
         XCTAssertGreaterThan(thirdPartyResource2.resource.duration, 0)
         XCTAssertNil(thirdPartyResource2.dd.traceId, "3rd party RUM Resources should not be traced")
         XCTAssertNil(thirdPartyResource2.dd.spanId, "3rd party RUM Resources should not be traced")
+        XCTAssertNil(thirdPartyResource2.dd.rulePsr, "Not traced resource should not send sample rate")
 
         XCTAssertTrue(
             thirdPartyResource1.resource.dns != nil || thirdPartyResource2.resource.dns != nil,
@@ -237,4 +242,8 @@ class RUMResourcesScenarioTests: IntegrationTests, RUMCommonAsserts {
         header?.removeFirst(prefix.count)
         return header
     }
+
+    private func isValid(sampleRate: Double) -> Bool {
+        return sampleRate >= 0 && sampleRate <= 1
+    }
 }
@@ -289,6 +289,32 @@ extension RUMAddViewTimingCommand: AnyMockable, RandomMockable {
     }
 }
 
+extension RUMSpanContext: AnyMockable, RandomMockable {
+    static func mockAny() -> RUMSpanContext {
+        return .mockWith()
+    }
+
+    static func mockRandom() -> RUMSpanContext {
+        return RUMSpanContext(
+            traceID: .mockRandom(),
+            spanID: .mockRandom(),
+            samplingRate: .mockRandom()
+        )
+    }
+
+    static func mockWith(
+        traceID: String = .mockAny(),
+        spanID: String = .mockAny(),
+        samplingRate: Double = .mockAny()
+    ) -> RUMSpanContext {
+        return RUMSpanContext(
+            traceID: traceID,
+            spanID: spanID,
+            samplingRate: samplingRate
+        )
+    }
+}
+
 extension RUMStartResourceCommand: AnyMockable, RandomMockable {
     static func mockAny() -> RUMStartResourceCommand { mockWith() }
 
@@ -301,7 +327,7 @@ extension RUMStartResourceCommand: AnyMockable, RandomMockable {
             httpMethod: .mockRandom(),
             kind: .mockAny(),
             isFirstPartyRequest: .mockRandom(),
-            spanContext: .init(traceID: .mockRandom(), spanID: .mockRandom())
+            spanContext: .init(traceID: .mockRandom(), spanID: .mockRandom(), samplingRate: .mockAny())
         )
     }
 
@@ -313,7 +339,7 @@ extension RUMStartResourceCommand: AnyMockable, RandomMockable {
         httpMethod: RUMMethod = .mockAny(),
         kind: RUMResourceType = .mockAny(),
         isFirstPartyRequest: Bool = .mockAny(),
-        spanContext: RUMSpanContext? = nil
+        spanContext: RUMSpanContext? = .mockAny()
     ) -> RUMStartResourceCommand {
         return RUMStartResourceCommand(
             resourceKey: resourceKey,
@@ -784,7 +810,7 @@ extension RUMResourceScope {
         httpMethod: RUMMethod = .mockAny(),
         isFirstPartyResource: Bool? = nil,
         resourceKindBasedOnRequest: RUMResourceType? = nil,
-        spanContext: RUMSpanContext? = nil,
+        spanContext: RUMSpanContext? = .mockAny(),
         onResourceEventSent: @escaping () -> Void = {},
         onErrorEventSent: @escaping () -> Void = {}
     ) -> RUMResourceScope {

@@ -370,10 +370,14 @@ extension Bool: AnyMockable {
     }
 }
 
-extension Float: AnyMockable {
+extension Float: AnyMockable, RandomMockable {
     static func mockAny() -> Float {
         return 0
     }
+
+    static func mockRandom() -> Float {
+        return .random(in: -Float(Int.min)...Float(Int.max))
+    }
 }
 
 extension Double: AnyMockable, RandomMockable {

@@ -11,10 +11,15 @@ extension ResourceMetrics: EquatableInTests {}
 
 class URLSessionRUMResourcesHandlerTests: XCTestCase {
     private let dateProvider = RelativeDateProvider(using: .mockDecember15th2019At10AMUTC())
+    private let traceSamplingRate: Double = .mockRandom(min: 0, max: 1)
     private let commandSubscriber = RUMCommandSubscriberMock()
 
     private func createHandler(rumAttributesProvider: URLSessionRUMAttributesProvider? = nil) -> URLSessionRUMResourcesHandler {
-        let handler = URLSessionRUMResourcesHandler(dateProvider: dateProvider, rumAttributesProvider: rumAttributesProvider)
+        let handler = URLSessionRUMResourcesHandler(
+            dateProvider: dateProvider,
+            tracingSampler: Sampler(samplingRate: Float(traceSamplingRate * 100)),
+            rumAttributesProvider: rumAttributesProvider
+        )
         handler.publish(to: commandSubscriber)
         return handler
     }
@@ -61,8 +66,10 @@ class URLSessionRUMResourcesHandlerTests: XCTestCase {
         waitForExpectations(timeout: 0.5, handler: nil)
 
         let resourceStartCommand = try XCTUnwrap(commandSubscriber.lastReceivedCommand as? RUMStartResourceCommand)
-        XCTAssertEqual(resourceStartCommand.spanContext?.traceID, "1")
-        XCTAssertEqual(resourceStartCommand.spanContext?.spanID, "2")
+        let spanContext = try XCTUnwrap(resourceStartCommand.spanContext)
+        XCTAssertEqual(spanContext.traceID, "1")
+        XCTAssertEqual(spanContext.spanID, "2")
+        XCTAssertEqual(spanContext.samplingRate, traceSamplingRate, accuracy: 0.01)
     }
 
     func testGivenTaskInterceptionWithMetricsAndResponse_whenInterceptionCompletes_itStopsRUMResourceWithMetrics() throws {