[iOS] Add isTracingActive

Author: FranAguilera

platform/swift/source/CaptureRustBridge.h

@@ -307,6 +307,15 @@ void capture_api_release_stream(stream_id);
  */
 bool capture_runtime_bool_variable_value(logger_id logger_id, const char *variable_name, bool default_value);
 
+/*
+ * Checks whether tracing is currently active for the logger/session.
+ *
+ * @param logger_id the logger to query.
+ *
+ * @returns true if tracing is active, false otherwise.
+ */
+bool capture_is_tracing_active(logger_id logger_id);
+
 /*
  * Returns the value of an integer runtime variable via client runtime configuration.
  *

platform/swift/source/CoreLogger.swift

@@ -13,6 +13,10 @@ import Foundation
 final class CoreLogger {
     private let underlyingLogger: LoggerBridging
 
+    var isTracingActive: Bool {
+        self.underlyingLogger.isTracingActive
+    }
+
     /// Initializes a new instance of the logger using provided Rust Logger bridging logger creation closure.
     /// It breaks-down Rust logger initialization process into two separate stages:
     /// initialization and the actual start of the logger. This separation helps us to avoid data race

platform/swift/source/Logger.swift

@@ -606,6 +606,14 @@ extension Logger: Logging {
 // MARK: - Features
 
 extension Logger {
+    internal var isTracingActive: Bool {
+        (self.underlyingLogger as? CoreLogger)?.isTracingActive == true
+    }
+
+    internal func runtimeValue<T: RuntimeValue>(_ variable: RuntimeVariable<T>) -> T {
+        self.underlyingLogger.runtimeValue(variable)
+    }
+
     static func setUpMemoryStateMonitoring(
         logger: CoreLogging
     ) -> DispatchSourceMemoryMonitor

platform/swift/source/LoggerBridge.swift

@@ -65,6 +65,10 @@ final class LoggerBridge: LoggerBridging {
     let loggerID: LoggerID
     private var blockingShutdown = false
 
+    var isTracingActive: Bool {
+        capture_is_tracing_active(self.loggerID)
+    }
+
     init?(
         apiKey: String,
         bufferDirectoryPath: String,

platform/swift/source/LoggerBridging.swift

@@ -14,6 +14,8 @@ typealias InternalFields = [CapturePassable.Field]
 /// An abstraction around Rust logger calls. It's main purpose is to help with dependency injection so that
 /// tests do not call into Rust methods.
 protocol LoggerBridging {
+    var isTracingActive: Bool { get }
+
     func log(
         level: LogLevel,
         message: @autoclosure () -> String,

platform/swift/source/integrations/url_session/TracePropagation.swift

@@ -40,6 +40,14 @@ enum URLSessionTracePropagation {
     static let xB3TraceIDHeader = "X-B3-TraceId"
     static let xB3SpanIDHeader = "X-B3-SpanId"
     static let xB3SampledHeader = "X-B3-Sampled"
+
+    static func traceparentValue(traceContext: URLSessionTraceContext) -> String {
+        "00-\(traceContext.traceID)-\(traceContext.spanID)-01"
+    }
+
+    static func b3SingleValue(traceContext: URLSessionTraceContext) -> String {
+        "\(traceContext.traceID)-\(traceContext.spanID)-1"
+    }
 }
 
 struct URLSessionTraceContext {

platform/swift/source/integrations/url_session/URLSessionIntegration.swift

@@ -70,6 +70,19 @@ final class URLSessionIntegration {
         return self.underlyingResponseFieldProvider.load()
     }
 
+    var tracePropagationMode: URLSessionTracePropagationMode {
+        guard let logger = Logger.getShared() as? Logger else {
+            return .disabled
+        }
+
+        let runtimeValue = logger.runtimeValue(.tracePropagationMode)
+        return URLSessionTracePropagationMode(runtimeValue: runtimeValue)
+    }
+
+    var isTracingActive: Bool {
+        (Logger.getShared() as? Logger)?.isTracingActive == true
+    }
+
     func start(
         logger: Logging,
         disableSwizzling: Bool,

platform/swift/source/integrations/url_session/extensions/URLSessionTask+Swizzling.swift

@@ -19,6 +19,41 @@ extension URLSessionTask {
             return
         }
 
+        let integration = URLSessionIntegration.shared
+        let mode = integration.tracePropagationMode
+        guard mode != .disabled, integration.isTracingActive else {
+            return
+        }
+
+        let traceContext = URLSessionTraceContext.make()
+        self.cap_traceContext = traceContext
+
+        if let request = self.originalRequest, let mutableRequest = (request as NSURLRequest).mutableCopy() as? NSMutableURLRequest {
+            switch mode {
+            case .w3c:
+                mutableRequest.setValue(
+                    URLSessionTracePropagation.traceparentValue(traceContext: traceContext),
+                    forHTTPHeaderField: URLSessionTracePropagation.traceparentHeader
+                )
+            case .b3Single:
+                mutableRequest.setValue(
+                    URLSessionTracePropagation.b3SingleValue(traceContext: traceContext),
+                    forHTTPHeaderField: URLSessionTracePropagation.b3Header
+                )
+            case .b3Multi:
+                mutableRequest.setValue(traceContext.traceID, forHTTPHeaderField: URLSessionTracePropagation.xB3TraceIDHeader)
+                mutableRequest.setValue(traceContext.spanID, forHTTPHeaderField: URLSessionTracePropagation.xB3SpanIDHeader)
+                mutableRequest.setValue("1", forHTTPHeaderField: URLSessionTracePropagation.xB3SampledHeader)
+            case .disabled:
+                break
+            }
+
+            mutableRequest.setValue(traceContext.traceID, forHTTPHeaderField: URLSessionTracePropagation.traceIDHeader)
+            try? ObjCWrapper.doTry {
+                self.setValue(mutableRequest as URLRequest, forKey: "originalRequest")
+            }
+        }
+
         URLSessionTaskTracker.shared.taskWillStart(self)
         try? ObjCWrapper.doTry {
             self.delegate = ProxyURLSessionTaskDelegate(target: self.delegate)

platform/swift/source/src/bridge.rs

@@ -652,6 +652,15 @@ extern "C" fn capture_runtime_bool_variable_value(
   )
 }
 
+#[no_mangle]
+extern "C" fn capture_is_tracing_active(logger_id: LoggerId<'_>) -> bool {
+  with_handle_unexpected_or(
+    move || Ok(logger_id.is_tracing_active()),
+    false,
+    "swift is tracing active",
+  )
+}
+
 #[no_mangle]
 extern "C" fn capture_runtime_uint32_variable_value(
   logger_id: LoggerId<'_>,

test/platform/swift/unit_integration/integrations/URLSessionIntegrationTests.swift

@@ -959,3 +959,88 @@ final class URLSessionIntegrationTests: XCTestCase {
         return url
     }
 }
+
+final class URLSessionTracePropagationTests: XCTestCase {
+    private var loggerBridge: MockLoggerBridging!
+
+    override func setUp() {
+        super.setUp()
+        self.loggerBridge = MockLoggerBridging()
+        URLSessionIntegration.shared.disableURLSessionTaskSwizzling()
+
+        let logger: Logger? = Logger(
+            withAPIKey: "123",
+            remoteErrorReporter: nil,
+            configuration: .init(rootFileURL: FileManager.default.temporaryDirectory.appendingPathComponent("bitdrift_test_\(UUID().uuidString)")),
+            sessionStrategy: .fixed(),
+            dateProvider: nil,
+            fieldProviders: [],
+            enableNetwork: false,
+            storageProvider: MockStorageProvider(),
+            timeProvider: MockTimeProvider(),
+            loggerBridgingFactoryProvider: MockLoggerBridgingFactory(logger: self.loggerBridge)
+        )
+        guard let sharedLogger = logger else {
+            XCTFail("failed to initialize test logger")
+            return
+        }
+        Logger.resetShared(logger: sharedLogger)
+
+        URLSessionIntegration.shared.start(
+            logger: sharedLogger,
+            disableSwizzling: false,
+            requestFieldProvider: nil,
+            responseFieldProvider: nil
+        )
+    }
+
+    override func tearDown() {
+        URLSessionIntegration.shared.disableURLSessionTaskSwizzling()
+        Logger.resetShared()
+        super.tearDown()
+    }
+
+    func testCapResume_whenTracingInactive_shouldNotAttachTraceContext() throws {
+        self.loggerBridge.tracingActive = false
+        self.loggerBridge.mockRuntimeVariable(.tracePropagationMode, with: "w3c")
+
+        let session = URLSession(configuration: .default)
+        let task = session.dataTask(with: URL(staticString: "https://api-fe.bitdrift.io/fe/ping?q=test"))
+
+        task.cap_resume()
+
+        XCTAssertNil(task.cap_traceContext)
+        task.cancel()
+        session.invalidateAndCancel()
+    }
+
+    func testCapResume_whenModeDisabled_shouldNotAttachTraceContext() throws {
+        self.loggerBridge.tracingActive = true
+        self.loggerBridge.mockRuntimeVariable(.tracePropagationMode, with: "none")
+
+        let session = URLSession(configuration: .default)
+        let task = session.dataTask(with: URL(staticString: "https://api-fe.bitdrift.io/fe/ping?q=test"))
+
+        task.cap_resume()
+
+        XCTAssertNil(task.cap_traceContext)
+        task.cancel()
+        session.invalidateAndCancel()
+    }
+
+    func testCapResume_whenW3CEnabled_shouldAttachTraceContext() throws {
+        self.loggerBridge.tracingActive = true
+        self.loggerBridge.mockRuntimeVariable(.tracePropagationMode, with: "w3c")
+
+        let session = URLSession(configuration: .default)
+        let task = session.dataTask(with: URL(staticString: "https://api-fe.bitdrift.io/fe/ping?q=test"))
+
+        task.cap_resume()
+
+        let traceContext = try XCTUnwrap(task.cap_traceContext)
+        XCTAssertEqual(32, traceContext.traceID.count)
+        XCTAssertEqual(16, traceContext.spanID.count)
+        task.cancel()
+        session.invalidateAndCancel()
+    }
+}