feat: Allow Hybrid SDKs to setTrace

Sources/Sentry/PrivateSentrySDKOnly.mm

@@ -9,6 +9,7 @@
 #import "SentryInternalDefines.h"
 #import "SentryMeta.h"
 #import "SentryOptions+Private.h"
+#import "SentryPropagationContext.h"
 #import "SentrySDK+Private.h"
 #import "SentrySerialization.h"
 #import "SentrySessionReplayIntegration+Private.h"
@@ -199,6 +200,14 @@
     return [SentryDependencyContainer.sharedInstance.extraContextProvider getExtraContext];
 }
 
++ (void)setTrace:(SentryId *)traceId spanId:(SentrySpanId *)spanId
+{
+    [SentrySDK.currentHub configureScope:^(SentryScope *scope) {
+        scope.propagationContext = [[SentryPropagationContext alloc] initWithTraceId:traceId
+                                                                              spanId:spanId];
+    }];
+}
+
 #if SENTRY_TARGET_PROFILING_SUPPORTED
 + (uint64_t)startProfilerForTrace:(SentryId *)traceId;
 {

Sources/Sentry/SentryPropagationContext.h

@@ -12,6 +12,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, strong, readonly) SentrySpanId *spanId;
 @property (nonatomic, readonly) SentryTraceHeader *traceHeader;
 
+- (instancetype)initWithTraceId:(SentryId *)traceId spanId:(SentrySpanId *)spanId;
+
 - (NSDictionary<NSString *, NSString *> *)traceContextForEvent;
 
 @end

Sources/Sentry/SentryPropagationContext.m

@@ -14,6 +14,15 @@ - (instancetype)init
     return self;
 }
 
+- (instancetype)initWithTraceId:(SentryId *)traceId spanId:(SentrySpanId *)spanId
+{
+    if (self = [super init]) {
+        _traceId = traceId;
+        _spanId = spanId;
+    }
+    return self;
+}
+
 - (SentryTraceHeader *)traceHeader
 {
     return [[SentryTraceHeader alloc] initWithTraceId:self.traceId

Sources/Sentry/SentryScope.m

@@ -154,6 +154,20 @@ - (void)setSpan:(nullable id<SentrySpan>)span
     }
 }
 
+- (void)setPropagationContext:(SentryPropagationContext *)propagationContext
+{
+    @synchronized(_propagationContext) {
+        _propagationContext = propagationContext;
+
+        if (self.observers.count > 0) {
+            NSDictionary *traceContext = [self.propagationContext traceContextForEvent];
+            for (id<SentryScopeObserver> observer in self.observers) {
+                [observer setTraceContext:traceContext];
+            }
+        }
+    }
+}
+
 - (nullable id<SentrySpan>)span
 {
     @synchronized(_spanLock) {

Sources/Sentry/include/HybridPublic/PrivateSentrySDKOnly.h

@@ -18,6 +18,7 @@
 @class SentryUser;
 @class SentryEnvelope;
 @class SentryId;
+@class SentrySpanId;
 @class SentrySessionReplayIntegration;
 @class UIView;
 
@@ -103,6 +104,11 @@ typedef void (^SentryOnAppStartMeasurementAvailable)(
  */
 + (NSDictionary *)getExtraContext;
 
+/**
+ * Allows Hybrids SDKs to thread-safe set the current trace.
+ */
++ (void)setTrace:(SentryId *)traceId spanId:(SentrySpanId *)spanId;
+
 #if SENTRY_TARGET_PROFILING_SUPPORTED
 /**
  * Start a profiler session associated with the given @c SentryId.

Sources/Sentry/include/SentryScope+Private.h

@@ -20,7 +20,10 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @property (atomic, strong) SentryUser *_Nullable userObject;
 
-@property (atomic, strong) SentryPropagationContext *propagationContext;
+/**
+ * The propagation context has a setter, requiring it to be nonatomic
+ */
+@property (nonatomic, strong) SentryPropagationContext *propagationContext;
 
 @property (nonatomic, nullable, copy) NSString *currentScreen;
 

Tests/SentryTests/SentryPropagationContextTests.swift

@@ -0,0 +1,41 @@
+@testable import Sentry
+import XCTest
+
+class SentryPropagationContextTests: XCTestCase {
+
+    func testInitWithTraceIdSpanId() {
+        let traceId = SentryId()
+        let spanId = SpanId()
+
+        let context = SentryPropagationContext(traceId: traceId, spanId: spanId)
+
+        XCTAssertEqual(traceId, context.traceId)
+        XCTAssertEqual(spanId, context.spanId)
+    }
+
+    func testTraceContextForEvent() {
+        let traceId = SentryId()
+        let spanId = SpanId()
+
+        let context = SentryPropagationContext(traceId: traceId, spanId: spanId)
+
+        let traceContext = context.traceContextForEvent()
+
+        XCTAssertEqual(traceContext.count, 2)
+        XCTAssertEqual(traceContext["trace_id"], traceId.sentryIdString)
+        XCTAssertEqual(traceContext["span_id"], spanId.sentrySpanIdString)
+    }
+
+    func testTraceHeader() {
+        let traceId = SentryId()
+        let spanId = SpanId()
+
+        let context = SentryPropagationContext(traceId: traceId, spanId: spanId)
+
+        let traceHeader = context.traceHeader
+
+        XCTAssertNotNil(traceHeader)
+        XCTAssertEqual(traceHeader.traceId, traceId)
+        XCTAssertEqual(traceHeader.spanId, spanId)
+    }
+} 

Tests/SentryTests/SentryScopeSwiftTests.swift

@@ -843,6 +843,26 @@ class SentryScopeSwiftTests: XCTestCase {
         XCTAssertEqual(observer2.context as? NSDictionary, expected)
     }
 
+    func testScopeObserver_setPropagationContext_UpdatesTraceContext() throws {
+        // -- Arrange --
+        let sut = Scope()
+        let observer = fixture.observer
+        sut.add(observer)
+
+        let traceId = SentryId(uuidString: "12345678123456781234567812345678")
+        let spanId = SpanId(value: "1234567812345678")
+        let propagationContext = SentryPropagationContext(trace: traceId, spanId: spanId)
+
+        // -- Act --
+        sut.propagationContext = propagationContext
+
+        // -- Assert -- 
+        let traceContext = try XCTUnwrap(observer.traceContext)
+        XCTAssertEqual(2, traceContext.count)
+        XCTAssertEqual(traceId.sentryIdString, traceContext["trace_id"] as? String)
+        XCTAssertEqual(spanId.sentrySpanIdString, traceContext["span_id"] as? String)
+    }
+
     private class TestScopeObserver: NSObject, SentryScopeObserver {
         var tags: [String: String]?
         func setTags(_ tags: [String: String]?) {