Prototype iOS changes

Author: FranAguilera

platform/swift/source/CaptureRustBridge.h

@@ -318,6 +318,17 @@ bool capture_runtime_bool_variable_value(logger_id logger_id, const char *variab
  */
 uint32_t capture_runtime_uint32_variable_value(logger_id logger_id, const char *variable_name, uint32_t default_value);
 
+/*
+ * Returns the value of a string runtime variable via client runtime configuration.
+ *
+ * @param logger_id the logger to check the variable value for.
+ * @param variable_name the name of the string variable to check.
+ * @param default_value the default value to use when the relevant configuration entry is missing.
+ *
+ * @returns the value of the string variable.
+ */
+NSString * capture_runtime_string_variable_value(logger_id logger_id, const char *variable_name, const char *default_value);
+
 /*
  * Records the session replay record capture screen duration.
  *

platform/swift/source/Logging.swift

@@ -7,6 +7,10 @@
 
 import Foundation
 
+protocol RuntimeVariableLoading {
+    func runtimeValue<T: RuntimeValue>(_ variable: RuntimeVariable<T>) -> T
+}
+
 /// A Capture SDK logger interface.
 public protocol Logging {
     /// Retrieves the session ID.

platform/swift/source/RuntimeVariable.swift

@@ -13,6 +13,7 @@ protocol RuntimeValue {}
 
 extension Bool: RuntimeValue {}
 extension UInt32: RuntimeValue {}
+extension String: RuntimeValue {}
 
 /// The runtime variable.
 struct RuntimeVariable<T: RuntimeValue> {
@@ -31,6 +32,9 @@ extension RuntimeVariable {
         } else if T.self == UInt32.self {
             // swiftlint:disable:next force_cast
             capture_runtime_uint32_variable_value(loggerID, self.name, self.defaultValue as! UInt32) as! T
+        } else if T.self == String.self {
+            // swiftlint:disable:next force_cast
+            capture_runtime_string_variable_value(loggerID, self.name, self.defaultValue as! String) as! T
         } else {
             fatalError("unsupported runtime variable type")
         }
@@ -111,3 +115,10 @@ extension RuntimeVariable<UInt32> {
         defaultValue: 90
     )
 }
+
+extension RuntimeVariable<String> {
+    static let tracePropagationMode = RuntimeVariable(
+        name: "client_feature.ios.trace_propagation_mode",
+        defaultValue: "w3c"
+    )
+}

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

@@ -0,0 +1,72 @@
+// capture-sdk - bitdrift's client SDK
+// Copyright Bitdrift, Inc. All rights reserved.
+//
+// Use of this source code is governed by a source available license that can be found in the
+// LICENSE file or at:
+// https://polyformproject.org/wp-content/uploads/2020/06/PolyForm-Shield-1.0.0.txt
+
+import Foundation
+import Security
+
+enum URLSessionTracePropagationMode {
+    case w3c
+    case b3Single
+    case b3Multi
+    case disabled
+
+    init(runtimeValue: String) {
+        switch runtimeValue
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased()
+        {
+        case "b3-single":
+            self = .b3Single
+        case "b3-multi":
+            self = .b3Multi
+        case "w3c"
+            self = .w3c    
+        default:
+            self = .disabled
+        }
+    }
+}
+
+enum URLSessionTracePropagation {
+    static let traceIDField = "_trace_id"
+    static let traceIDHeader = "x-capture-span-trace-id"
+    static let legacyTraceIDHeader = "x-capture-span-trace-field-trace_id"
+    static let traceparentHeader = "traceparent"
+    static let b3Header = "b3"
+    static let xB3TraceIDHeader = "X-B3-TraceId"
+    static let xB3SpanIDHeader = "X-B3-SpanId"
+    static let xB3SampledHeader = "X-B3-Sampled"
+}
+
+struct URLSessionTraceContext {
+    let traceID: String
+    let spanID: String
+
+    static func make() -> URLSessionTraceContext {
+        URLSessionTraceContext(traceID: Self.hexString(byteCount: 16), spanID: Self.hexString(byteCount: 8))
+    }
+
+    private static func hexString(byteCount: Int) -> String {
+        var bytes = [UInt8](repeating: 0, count: byteCount)
+        let status = SecRandomCopyBytes(kSecRandomDefault, byteCount, &bytes)
+        if status != errSecSuccess {
+            for index in bytes.indices {
+                bytes[index] = UInt8.random(in: UInt8.min ... UInt8.max)
+            }
+        }
+
+        let hexDigits = Array("0123456789abcdef".utf8)
+        var output = [UInt8]()
+        output.reserveCapacity(byteCount * 2)
+        for byte in bytes {
+            output.append(hexDigits[Int(byte >> 4)])
+            output.append(hexDigits[Int(byte & 0x0f)])
+        }
+
+        return String(decoding: output, as: UTF8.self)
+    }
+}

platform/swift/source/integrations/url_session/URLSessionTaskTracker.swift

@@ -29,6 +29,20 @@ final class URLSessionTaskTracker {
 
     static let shared = URLSessionTaskTracker()
 
+    static func enrichExtraFields(
+        _ extraFields: Fields?,
+        with traceContext: URLSessionTraceContext?
+    ) -> Fields?
+    {
+        guard let traceContext else {
+            return extraFields
+        }
+
+        var updatedExtraFields = extraFields ?? [:]
+        updatedExtraFields[URLSessionTracePropagation.traceIDField] = traceContext.traceID
+        return updatedExtraFields
+    }
+
     /// Ensures the given task type is supported by our current network instrumentation. Some of these don't
     /// have all properties we
     /// access, and those are only known at runtime. To play safe, we only check the positive case here we
@@ -62,6 +76,7 @@ final class URLSessionTaskTracker {
             if let originalRequest = task.originalRequest {
                 extraFields = URLSessionIntegration.shared.requestFieldProvider?.provideExtraFields(for: originalRequest)
             }
+            extraFields = Self.enrichExtraFields(extraFields, with: task.cap_traceContext)
             guard let requestInfo = HTTPRequestInfo(task: task, extraFields: extraFields) else {
                 return
             }
@@ -92,6 +107,7 @@ final class URLSessionTaskTracker {
                     for: httpURLResponse
                 )
             }
+            extraFields = Self.enrichExtraFields(extraFields, with: task.cap_traceContext)
             let responseInfo = HTTPResponseInfo(
                 requestInfo: requestInfo,
                 response: httpResponse,
@@ -100,6 +116,7 @@ final class URLSessionTaskTracker {
             )
 
             URLSessionIntegration.shared.logger?.log(responseInfo, file: nil, line: nil, function: nil)
+            task.cap_traceContext = nil
         }
     }
 }

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

@@ -8,6 +8,7 @@
 import Foundation
 
 private var kRequestInfoKey: UInt8 = 0
+private var kTraceContextKey: UInt8 = 0
 
 extension URLSessionTask {
     /// The HTTP Request Info associated with a given `URLSessionTask`.
@@ -18,4 +19,11 @@ extension URLSessionTask {
             objc_setAssociatedObject(self, &kRequestInfoKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
         }
     }
+
+    var cap_traceContext: URLSessionTraceContext? {
+        get { objc_getAssociatedObject(self, &kTraceContextKey) as? URLSessionTraceContext }
+        set {
+            objc_setAssociatedObject(self, &kTraceContextKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        }
+    }
 }

platform/swift/source/src/bridge.rs

@@ -17,31 +17,20 @@ use anyhow::anyhow;
 use bd_api::{Platform, PlatformNetworkManager, PlatformNetworkStream, StreamEvent};
 use bd_crash_handler::{CrashReportHook, CrashReportInfo};
 use bd_error_reporter::reporter::{
-  handle_unexpected,
-  with_handle_unexpected,
-  with_handle_unexpected_or,
-  MetadataErrorReporter,
+  handle_unexpected, with_handle_unexpected, with_handle_unexpected_or, MetadataErrorReporter,
   UnexpectedErrorHandler,
 };
 use bd_logger::{
-  Block,
-  CaptureSession,
-  LogAttributesOverrides,
-  LogFieldKind,
-  LogFields,
-  LogLevel,
-  MetadataProvider,
-  ReportProcessingSession,
+  Block, CaptureSession, LogAttributesOverrides, LogFieldKind, LogFields, LogLevel,
+  MetadataProvider, ReportProcessingSession,
 };
 use bd_noop_network::NoopNetwork;
 use bd_proto::flatbuffers::report::bitdrift_public::fbs::issue_reporting::v_1;
 use bd_proto::protos::logging::payload::LogType;
 use objc::rc::StrongPtr;
 use objc::runtime::Object;
 use platform_shared::javascript_error::{
-  persist_javascript_error_report,
-  AppMetadata,
-  DeviceMetadata,
+  persist_javascript_error_report, AppMetadata, DeviceMetadata,
 };
 use platform_shared::metadata::{self, Mobile};
 use platform_shared::{LoggerHolder, LoggerId};
@@ -257,7 +246,7 @@ impl<W: StreamWriter + Send> PlatformNetworkStream for SwiftNetworkStream<W> {
         return Ok(());
       }
 
-      slice = &slice[written ..];
+      slice = &slice[written..];
     }
   }
 }
@@ -570,15 +559,13 @@ extern "C" fn capture_create_logger(
         static_metadata,
         start_in_sleep_mode,
       })
-      .with_crash_report_hook(
-        if issue_callback_configuration.is_null() {
-          None
-        } else {
-          Some(Arc::new(IssueCallbackConfigurationHandle::new(
-            issue_callback_configuration,
-          )))
-        },
-      )
+      .with_crash_report_hook(if issue_callback_configuration.is_null() {
+        None
+      } else {
+        Some(Arc::new(IssueCallbackConfigurationHandle::new(
+          issue_callback_configuration,
+        )))
+      })
       .with_internal_logger(true)
       .build()
       .map(|(logger, _, future, _)| LoggerHolder::new(logger, future))?;
@@ -672,6 +659,29 @@ extern "C" fn capture_runtime_uint32_variable_value(
   )
 }
 
+#[no_mangle]
+extern "C" fn capture_runtime_string_variable_value(
+  logger_id: LoggerId<'_>,
+  variable_name: *const c_char,
+  default_value: *const c_char,
+) -> *const Object {
+  with_handle_unexpected_or(
+    move || {
+      let variable_name = unsafe { CStr::from_ptr(variable_name) }.to_str()?;
+      let default_value = unsafe { CStr::from_ptr(default_value) }
+        .to_str()?
+        .to_string();
+      let value = logger_id
+        .runtime_snapshot()
+        .get_string(variable_name, default_value);
+
+      Ok(make_nsstring(&value)?.autorelease())
+    },
+    make_empty_nsstring().autorelease(),
+    "swift runtime string value",
+  )
+}
+
 #[no_mangle]
 extern "C" fn capture_write_log(
   logger_id: LoggerId<'_>,