fix(tracing): Skip native frames and stall tracking for unsampled spans

The NativeFrames and StallTracking integrations performed their full
work (native bridge calls, 50ms polling loop) regardless of whether the
span would be sampled, unlike the Profiling integration which already
checks spanIsSampled() correctly.

With tracesSampleRate: 0.2, this meant 80% of navigation spans triggered
unnecessary fetchNativeFrames() bridge calls and stall tracking loop
activations. On low-end devices these operations are significantly more
expensive and contribute to the performance overhead reported in #5665.

The fix adds a spanIsSampled() guard at the entry of fetchStartFramesForSpan
in NativeFrames and _onSpanStart in StallTracking. Since end-frame fetching
already bails when no start frames are found, the single guard in
fetchStartFramesForSpan covers both start and end for NativeFrames.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: antonis

packages/core/src/js/tracing/integrations/nativeFrames.ts

@@ -1,5 +1,5 @@
 import type { Client, Event, Integration, Measurements, MeasurementUnit, Span } from '@sentry/core';
-import { debug, getRootSpan, spanToJSON, timestampInSeconds } from '@sentry/core';
+import { debug, getRootSpan, spanIsSampled, spanToJSON, timestampInSeconds } from '@sentry/core';
 import type { NativeFramesResponse } from '../../NativeRNSentry';
 import { AsyncExpiringMap } from '../../utils/AsyncExpiringMap';
 import { isRootSpan } from '../../utils/span';
@@ -86,6 +86,10 @@ export const nativeFramesIntegration = (): Integration => {
   };
 
   const fetchStartFramesForSpan = (span: Span): void => {
+    if (!spanIsSampled(span)) {
+      return;
+    }
+
     const spanId = span.spanContext().spanId;
     const spanType = isRootSpan(span) ? 'root' : 'child';
     debug.log(`[${INTEGRATION_NAME}] Fetching frames for ${spanType} span start (${spanId}).`);

packages/core/src/js/tracing/integrations/stalltracking.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import type { Client, Integration, Measurements, MeasurementUnit, Span } from '@sentry/core';
-import { debug, getRootSpan, spanToJSON, timestampInSeconds } from '@sentry/core';
+import { debug, getRootSpan, spanIsSampled, spanToJSON, timestampInSeconds } from '@sentry/core';
 import type { AppStateStatus } from 'react-native';
 import { AppState } from 'react-native';
 import { STALL_COUNT, STALL_LONGEST_TIME, STALL_TOTAL_TIME } from '../../measurements';
@@ -123,6 +123,10 @@ export const stallTrackingIntegration = ({
       return;
     }
 
+    if (!spanIsSampled(rootSpan)) {
+      return;
+    }
+
     if (statsByRootSpan.has(rootSpan)) {
       debug.error(
         '[StallTracking] Tried to start stall tracking on a transaction already being tracked. Measurements might be lost.',

packages/core/test/tracing/integrations/nativeframes.test.ts

@@ -520,4 +520,31 @@ describe('NativeFramesInstrumentation', () => {
       }),
     );
   });
+
+  describe('unsampled spans', () => {
+    beforeEach(() => {
+      global.Date.now = jest.fn(() => mockDate.getTime());
+
+      getCurrentScope().clear();
+      getIsolationScope().clear();
+      getGlobalScope().clear();
+
+      const options = getDefaultTestClientOptions({
+        tracesSampleRate: 0,
+        enableNativeFramesTracking: true,
+        integrations: [nativeFramesIntegration()],
+      });
+      client = new TestClient(options);
+      setCurrentClient(client);
+      client.init();
+    });
+
+    it('does not fetch native frames for unsampled spans', () => {
+      startSpan({ name: 'unsampled transaction', forceTransaction: true }, () => {
+        // span starts and ends — no work expected
+      });
+
+      expect(NATIVE.fetchNativeFrames).not.toHaveBeenCalled();
+    });
+  });
 });

packages/core/test/tracing/integrations/stallTracking/stalltracking.test.ts

@@ -225,4 +225,31 @@ describe('StallTracking', () => {
 
     expect(client.eventQueue[0].measurements).toBeUndefined();
   });
+
+  it('does not track stalls for unsampled spans', async () => {
+    getCurrentScope().clear();
+    getIsolationScope().clear();
+    getGlobalScope().clear();
+
+    const unsampledOptions = getDefaultTestClientOptions({
+      tracesSampleRate: 0,
+      enableStallTracking: true,
+      integrations: [stallTrackingIntegration()],
+      enableAppStartTracking: false,
+    });
+    const unsampledClient = new TestClient(unsampledOptions);
+    setCurrentClient(unsampledClient);
+    unsampledClient.init();
+
+    startSpan({ name: 'unsampled transaction', forceTransaction: true }, () => {
+      expensiveOperation();
+      jest.runOnlyPendingTimers();
+    });
+
+    await unsampledClient.flush();
+
+    // Event is either not sent or has no stall measurements
+    const event = unsampledClient.eventQueue[0];
+    expect(event?.measurements?.stall_count).toBeUndefined();
+  });
 });