getsentry · alwx · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026 · Sep 8, 2026
@@ -10,6 +10,8 @@
 
 ### Features
 
+- Sync JS scope propagation context to native scope ([#6686](https://github.com/getsentry/sentry-react-native/pull/6686))
+  - Native HTTP spans (OkHttp on Android, URLSession on iOS) now automatically share the same `trace_id` as the active JS navigation transaction, linking them in the Sentry trace waterfall.
 - Expose the iOS `enableMemoryIntrospection` option to omit memory contents from native crash reports ([#6547](https://github.com/getsentry/sentry-react-native/pull/6674))
 - Add `anrProfilingSampleRate` option to profile ANRs on Android ([#6673](https://github.com/getsentry/sentry-react-native/pull/6673))
 

@@ -33,6 +33,7 @@
 import io.sentry.IScope;
 import io.sentry.ISentryExecutorService;
 import io.sentry.ISerializer;
+import io.sentry.PropagationContext;
 import io.sentry.ScopesAdapter;
 import io.sentry.Sentry;
 import io.sentry.SentryAttributes;
@@ -677,6 +678,25 @@ public boolean setActiveSpanId(@Nullable String spanId) {
     return true; // The return ensure RN executes the code synchronously
   }
 
+  public boolean setCurrentScopePropagationContext(@Nullable ReadableMap ctx) {
+    if (ctx == null || !ctx.hasKey("traceId") || !ctx.hasKey("spanId")) {
+      return false;
+    }
+    String traceId = ctx.getString("traceId");
+    String spanId = ctx.getString("spanId");
+    if (traceId == null || spanId == null) {
+      return false;
+    }
+    Double sampleRand = ctx.hasKey("sampleRand") ? ctx.getDouble("sampleRand") : null;
+    Boolean sampled = ctx.hasKey("sampled") ? ctx.getBoolean("sampled") : null;
+
+    PropagationContext propagationContext =
+        PropagationContext.fromExistingTrace(traceId, spanId, null, sampleRand);
+    propagationContext.setSampled(sampled);
+    Sentry.configureScope(scope -> scope.setPropagationContext(propagationContext));
+    return true; // The return ensures RN executes the method synchronously
+  }
+
   public void setExtra(String key, String extra) {
     if (key == null || extra == null) {
       logger.log(

@@ -234,6 +234,11 @@ public boolean setActiveSpanId(String spanId) {
     return this.impl.setActiveSpanId(spanId);
   }
 
+  @Override
+  public boolean setCurrentScopePropagationContext(ReadableMap ctx) {
+    return this.impl.setCurrentScopePropagationContext(ctx);
+  }
+
   @Override
   public void enableShakeDetection() {
     this.impl.enableShakeDetection();

@@ -229,11 +229,16 @@ public void popTimeToDisplayFor(String key, Promise promise) {
     this.impl.popTimeToDisplayFor(key, promise);
   }
 
-  @ReactMethod
+  @ReactMethod(isBlockingSynchronousMethod = true)
   public boolean setActiveSpanId(String spanId) {
     return this.impl.setActiveSpanId(spanId);
   }
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean setCurrentScopePropagationContext(ReadableMap ctx) {
+    return this.impl.setCurrentScopePropagationContext(ctx);
+  }
+
   @ReactMethod
   public void enableShakeDetection() {
     this.impl.enableShakeDetection();

@@ -948,7 +948,7 @@ export function wrapTurboModule<T extends object>(name: string, module: T | null
 //
 // src/js/feedback/integration.ts:21:5 - (ae-forgotten-export) The symbol "ScreenshotButtonProps" needs to be exported by the entry point index.d.ts
 // src/js/feedback/integration.ts:23:5 - (ae-forgotten-export) The symbol "FeedbackFormTheme" needs to be exported by the entry point index.d.ts
-// src/js/tracing/reactnativetracing.ts:90:3 - (ae-forgotten-export) The symbol "ReactNativeTracingState" needs to be exported by the entry point index.d.ts
+// src/js/tracing/reactnativetracing.ts:95:3 - (ae-forgotten-export) The symbol "ReactNativeTracingState" needs to be exported by the entry point index.d.ts
 // src/js/tracing/reactnavigation.ts:228:3 - (ae-forgotten-export) The symbol "RouteOverrideProvider" needs to be exported by the entry point index.d.ts
 
 // (No @packageDocumentation comment for this package)

@@ -1137,6 +1137,17 @@ + (BOOL)isPathUnderAllowedRootsForTesting:(NSString *)path
     return @YES; // The return ensures that the method is synchronous
 }
 
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(
+    NSNumber *, setCurrentScopePropagationContext : (NSDictionary *)ctx)
+{
+    NSString *traceId = ctx[@"traceId"];
+    NSString *spanId = ctx[@"spanId"];
+    if (traceId && spanId) {
+        [RNSentryInternal setCurrentScopePropagationContextWithTraceId:traceId spanId:spanId];
+    }
+    return @YES;
+}
+
 RCT_EXPORT_METHOD(encodeToBase64 : (NSArray *)array resolver : (
     RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject)
 {

@@ -246,4 +246,25 @@
     ) -> [String: Any]? { nil }
     @_spi(Private) @objc public static func discardProfiler(forTrace traceId: SentryId) {}
     #endif
+
+    // MARK: - Scope propagation context
+
+    // Note: sampled and sampleRand from the JS propagation context are not applied here.
+    // SentrySDK.internal.setTrace only accepts traceId/spanId; wiring sampling fields
+    // through would require a sentry-cocoa API change.
+    @_spi(Private) @objc public static func setCurrentScopePropagationContext(traceId: String, spanId: String) {
+        // JS traceId is a 32-char hex string without hyphens; SentryId(uuidString:) requires
+        // the standard hyphenated UUID format (8-4-4-4-12), otherwise it silently produces
+        // an empty SentryId and trace linking breaks.
+        let hyphenated: String
+        if traceId.count == 32 {
+            let s = traceId
+            hyphenated = "\(s.prefix(8))-\(s.dropFirst(8).prefix(4))-\(s.dropFirst(12).prefix(4))-\(s.dropFirst(16).prefix(4))-\(s.dropFirst(20))"
+        } else {
+            hyphenated = traceId
+        }
+        let sentryTraceId = SentryId(uuidString: hyphenated)
+        let sentrySpanId = SpanId(value: spanId)
+        SentrySDK.internal.setTrace(sentryTraceId, spanId: sentrySpanId)
+    }
 }
@@ -59,6 +59,7 @@ export interface Spec extends TurboModule {
   getDataFromUri(uri: string): Promise<number[]>;
   popTimeToDisplayFor(key: string): Promise<number | undefined | null>;
   setActiveSpanId(spanId: string): boolean;
+  setCurrentScopePropagationContext(ctx: UnsafeObject): boolean;
   encodeToBase64(data: number[]): Promise<string | undefined | null>;
   enableShakeDetection(): void;
   disableShakeDetection(): void;

@@ -6,7 +6,12 @@ import { debug, getClient } from '@sentry/core';
 import { isExpoFetchEnabled, isWeb } from '../utils/environment';
 import { getDevServer } from './../integrations/debugsymbolicatorutils';
 import { getTransactionEventDiscardReason } from './onSpanEndUtils';
-import { addDefaultOpForSpanFrom, addThreadInfoToSpan, defaultIdleOptions } from './span';
+import {
+  addDefaultOpForSpanFrom,
+  addThreadInfoToSpan,
+  defaultIdleOptions,
+  syncPropagationContextToNative,
+} from './span';
 
 export const INTEGRATION_NAME = 'ReactNativeTracing';
 
@@ -131,6 +136,7 @@ export const reactNativeTracingIntegration = (
   const setup = (client: Client): void => {
     addDefaultOpForSpanFrom(client);
     addThreadInfoToSpan(client);
+    syncPropagationContextToNative(client);
 
     instrumentOutgoingRequests(client, {
       traceFetch: finalOptions.traceFetch,

@@ -6,19 +6,21 @@
  getActiveSpan,
  getClient,
  getCurrentScope,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SentryNonRecordingSpan,
+  spanIsSampled,
   SPAN_STATUS_ERROR,
   spanToJSON,
   startIdleSpan as coreStartIdleSpan,
 } from '@sentry/core';
 import { AppState, Platform } from 'react-native';
 
 import { isRootSpan } from '../utils/span';
+import { NATIVE } from '../wrapper';
 import { adjustTransactionDuration, cancelInBackground } from './onSpanEndUtils';
 import {
   SPAN_ORIGIN_AUTO_INTERACTION,
  SPAN_ORIGIN_AUTO_NAVIGATION_CUSTOM,
  SPAN_ORIGIN_MANUAL_INTERACTION,
 } from './origin';
@@ -202,3 +204,29 @@
   spanJSON.data[SPAN_THREAD_NAME] = SPAN_THREAD_NAME_MAIN;
   return spanJSON;
 }
+
+/**
+ * Pushes the JS root span's propagation context to the native scope so that
+ * native HTTP instrumentation (OkHttp on Android, URLSession on iOS) attaches
+ * the correct traceId and appears in the same trace as the JS transaction.
+ *
+ * Fires for every root span so that the native scope is always up to date and
+ * doesn't retain a stale traceId from a previous span. Child spans are skipped
+ * to avoid bridge spam.
+ *
+ * Note: `spanStart` fires before idle spans are made active, so an active-span
+ * guard here would skip every navigation span. Sync happens for all root spans.
+ */
+export function syncPropagationContextToNative(client: Client): void {
+  client.on('spanStart', (span: Span) => {
+    if (!isRootSpan(span)) return;
+    const ctx = span.spanContext();
+    const propagationCtx = getCurrentScope().getPropagationContext();
+    NATIVE.setCurrentScopePropagationContext({
+      traceId: ctx.traceId,
+      spanId: ctx.spanId,
+      sampled: spanIsSampled(span),
+      sampleRand: propagationCtx.sampleRand ?? Math.random(),
+    });
+  });
+}
@@ -146,6 +146,13 @@ interface SentryNativeWrapper {
 
   setActiveSpanId(spanId: string): void;
 
+  setCurrentScopePropagationContext(ctx: {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+    sampleRand: number;
+  }): boolean;
+
   encodeToBase64(data: Uint8Array): Promise<string | null>;
 
   primitiveProcessor(value: Primitive): string;
@@ -955,6 +962,18 @@ export const NATIVE: SentryNativeWrapper = {
     }
   },
 
+  setCurrentScopePropagationContext(ctx): boolean {
+    if (!this.enableNative || !this._isModuleLoaded(RNSentry)) {
+      return false;
+    }
+    try {
+      return !!RNSentry.setCurrentScopePropagationContext(ctx);
+    } catch (error) {
+      debug.error('Error:', error);
+      return false;
+    }
+  },
+
   async encodeToBase64(data: Uint8Array): Promise<string | null> {
     if (!this.enableNative || !this._isModuleLoaded(RNSentry)) {
       return Promise.resolve(null);

@@ -70,6 +70,7 @@ const NATIVE: MockInterface<NativeType> = {
   getDataFromUri: jest.fn(),
   popTimeToDisplayFor: jest.fn(),
   setActiveSpanId: jest.fn(),
+  setCurrentScopePropagationContext: jest.fn(),
   encodeToBase64: jest.fn(),
   primitiveProcessor: jest.fn(),
 };

@@ -22,6 +22,7 @@ jest.mock('../../src/js/wrapper', () => {
       fetchNativeAppStart: jest.fn(),
       fetchNativeFrames: jest.fn(() => Promise.resolve()),
       enableNativeFramesTracking: jest.fn(() => Promise.resolve()),
+      setCurrentScopePropagationContext: jest.fn(),
       enableNative: true,
     },
   };

@@ -60,6 +60,7 @@ jest.mock('../../../src/js/wrapper', () => {
       fetchNativeFrames: jest.fn(() => Promise.resolve()),
       disableNativeFramesTracking: jest.fn(() => Promise.resolve()),
       enableNativeFramesTracking: jest.fn(() => Promise.resolve()),
+      setCurrentScopePropagationContext: jest.fn(),
       enableNative: true,
     },
   };

@@ -0,0 +1,101 @@
+import type { Client } from '@sentry/core';
+
+import { getCurrentScope, SentryNonRecordingSpan, startInactiveSpan } from '@sentry/core';
+
+jest.mock('../../src/js/wrapper', () => ({
+  NATIVE: {
+    enableNative: true,
+    setCurrentScopePropagationContext: jest.fn(),
+  },
+}));
+
+jest.mock('react-native', () => ({
+  AppState: {
+    currentState: 'active',
+    addEventListener: jest.fn(() => ({ remove: jest.fn() })),
+  },
+  Platform: { OS: 'ios' },
+  NativeModules: { RNSentry: {} },
+}));
+
+import { syncPropagationContextToNative } from '../../src/js/tracing/span';
+import { NATIVE } from '../../src/js/wrapper';
+import { setupTestClient } from '../mocks/client';
+
+const mockSetPropagationContext = NATIVE.setCurrentScopePropagationContext as jest.Mock;
+
+describe('syncPropagationContextToNative', () => {
+  let client: Client;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    client = setupTestClient({ tracesSampleRate: 1.0 });
+    syncPropagationContextToNative(client);
+  });
+
+  it('calls NATIVE.setCurrentScopePropagationContext when a root span starts', () => {
+    const span = startInactiveSpan({ name: 'root', forceTransaction: true });
+    const ctx = span.spanContext();
+
+    expect(mockSetPropagationContext).toHaveBeenCalledTimes(1);
+    expect(mockSetPropagationContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        traceId: ctx.traceId,
+        spanId: ctx.spanId,
+      }),
+    );
+
+    span.end();
+  });
+
+  it('does not call NATIVE.setCurrentScopePropagationContext for child spans', () => {
+    const root = startInactiveSpan({ name: 'root', forceTransaction: true });
+    mockSetPropagationContext.mockClear();
+
+    const child = startInactiveSpan({ name: 'child', parentSpan: root });
+    expect(mockSetPropagationContext).not.toHaveBeenCalled();
+
+    child.end();
+    root.end();
+  });
+
+  it('calls NATIVE.setCurrentScopePropagationContext for SentryNonRecordingSpan to prevent stale native context', () => {
+    const nonRecording = new SentryNonRecordingSpan();
+    const ctx = nonRecording.spanContext();
+    client.emit('spanStart', nonRecording);
+
+    expect(mockSetPropagationContext).toHaveBeenCalledTimes(1);
+    expect(mockSetPropagationContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        traceId: ctx.traceId,
+        spanId: ctx.spanId,
+      }),
+    );
+  });
+
+  it('passes sampled and sampleRand from the scope propagation context', () => {
+    const span = startInactiveSpan({ name: 'root', forceTransaction: true });
+    const propagationCtx = getCurrentScope().getPropagationContext();
+
+    expect(mockSetPropagationContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sampled: expect.any(Boolean),
+        sampleRand: propagationCtx.sampleRand ?? expect.any(Number),
+      }),
+    );
+
+    span.end();
+  });
+
+  it('fires once per root span start', () => {
+    const span1 = startInactiveSpan({ name: 'first', forceTransaction: true });
+    span1.end();
+
+    const span2 = startInactiveSpan({ name: 'second', forceTransaction: true });
+    span2.end();
+
+    expect(mockSetPropagationContext).toHaveBeenCalledTimes(2);
+    expect(mockSetPropagationContext.mock.calls[0][0].spanId).toBe(span1.spanContext().spanId);
+    expect(mockSetPropagationContext.mock.calls[1][0].spanId).toBe(span2.spanContext().spanId);
+  });
+});