fix(core): Defer standalone app start send to avoid duplicate transactions

When appLoaded() is called after auto-capture in standalone mode, two
separate App Start transactions were sent to Sentry for the same launch.
This inflates transaction counts and produces inconsistent app start
metrics on the dashboard.

Fix: in standalone mode, auto-capture from ReactNativeProfiler now defers
the captureStandaloneAppStart() call via setTimeout(0) instead of sending
immediately. This gives appLoaded() a chance to cancel the deferred send
and replace it with a single transaction using the correct manual
timestamp.

If appLoaded() is never called, the deferred send fires on the next tick
and the existing behavior is preserved — only one transaction is sent.

Adds scheduleDeferredStandaloneCapture() and cancelDeferredStandaloneCapture()
methods on the AppStartIntegration type. Adds a test verifying the deferred
send fires when appLoaded() is not called.

Author: alwx

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

@@ -38,6 +38,8 @@ const INTEGRATION_NAME = 'AppStart';
 export type AppStartIntegration = Integration & {
   captureStandaloneAppStart: () => Promise<void>;
   resetAppStartDataFlushed: () => void;
+  cancelDeferredStandaloneCapture: () => void;
+  scheduleDeferredStandaloneCapture: () => void;
 };
 
 /**
@@ -112,6 +114,9 @@ export async function _appLoaded(): Promise<void> {
 
   const integration = client.getIntegrationByName<AppStartIntegration>(INTEGRATION_NAME);
   if (integration) {
+    // Cancel any deferred standalone send from auto-capture — we'll send our own
+    // with the correct manual timestamp instead of sending two transactions.
+    integration.cancelDeferredStandaloneCapture();
     // In standalone mode, auto-capture may have already flushed the transaction.
     // Reset the flag so captureStandaloneAppStart can re-send with the manual timestamp.
     integration.resetAppStartDataFlushed();
@@ -150,7 +155,19 @@ export async function _captureAppStart({ isManual }: { isManual: boolean }): Pro
   });
 
   await fetchAndUpdateEndFrames();
-  await client.getIntegrationByName<AppStartIntegration>(INTEGRATION_NAME)?.captureStandaloneAppStart();
+
+  const integration = client.getIntegrationByName<AppStartIntegration>(INTEGRATION_NAME);
+  if (integration) {
+    if (!isManual) {
+      // For auto-capture, defer the standalone send to give appLoaded() a chance
+      // to override the end timestamp before the transaction is sent.
+      // If appLoaded() is called, it cancels this deferred send and sends its own.
+      // In non-standalone mode, scheduleDeferredStandaloneCapture is a no-op.
+      integration.scheduleDeferredStandaloneCapture();
+    } else {
+      await integration.captureStandaloneAppStart();
+    }
+  }
 }
 
 /**
@@ -276,6 +293,7 @@ export const appStartIntegration = ({
   let firstStartedActiveRootSpanId: string | undefined = undefined;
   let firstStartedActiveRootSpan: Span | undefined = undefined;
   let cachedNativeAppStart: NativeAppStartResponse | null | undefined = undefined;
+  let deferredStandaloneTimeout: ReturnType<typeof setTimeout> | undefined = undefined;
 
   const setup = (client: Client): void => {
     _client = client;
@@ -305,6 +323,10 @@ export const appStartIntegration = ({
         firstStartedActiveRootSpan = undefined;
         isAppLoadedManuallyInvoked = false;
         cachedNativeAppStart = undefined;
+        if (deferredStandaloneTimeout !== undefined) {
+          clearTimeout(deferredStandaloneTimeout);
+          deferredStandaloneTimeout = undefined;
+        }
       } else {
         debug.log(
           '[AppStartIntegration] Waiting for initial app start was flush, before updating based on runApplication call.',
@@ -629,13 +651,34 @@ export const appStartIntegration = ({
     appStartDataFlushed = false;
   };
 
+  const cancelDeferredStandaloneCapture = (): void => {
+    if (deferredStandaloneTimeout !== undefined) {
+      clearTimeout(deferredStandaloneTimeout);
+      deferredStandaloneTimeout = undefined;
+      debug.log('[AppStart] Cancelled deferred standalone app start capture.');
+    }
+  };
+
+  const scheduleDeferredStandaloneCapture = (): void => {
+    if (!standalone) {
+      return;
+    }
+    deferredStandaloneTimeout = setTimeout(() => {
+      deferredStandaloneTimeout = undefined;
+      // oxlint-disable-next-line typescript-eslint(no-floating-promises)
+      captureStandaloneAppStart();
+    }, 0);
+  };
+
   return {
     name: INTEGRATION_NAME,
     setup,
     afterAllSetup,
     processEvent,
     captureStandaloneAppStart,
     resetAppStartDataFlushed,
+    cancelDeferredStandaloneCapture,
+    scheduleDeferredStandaloneCapture,
     setFirstStartedActiveRootSpanId,
   } as AppStartIntegration;
 };

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

@@ -1260,43 +1260,73 @@ describe('appLoaded() standalone mode', () => {
     integration.setup(standaloneClient);
     standaloneClient.addIntegration(integration);
 
-    // Simulate auto-capture from ReactNativeProfiler (componentDidMount)
+    // Simulate auto-capture from ReactNativeProfiler (componentDidMount).
+    // In standalone mode, auto-capture defers the send to give appLoaded() a chance.
     const autoTimeSeconds = Date.now() / 1000;
     mockFunction(timestampInSeconds).mockReturnValue(autoTimeSeconds);
     await _captureAppStart({ isManual: false });
-    await new Promise(resolve => setTimeout(resolve, 0));
-
-    // Auto-capture should have sent the standalone transaction
-    expect(standaloneClient.eventQueue.length).toBe(1);
-    const autoEvent = standaloneClient.eventQueue[0];
-    const autoSpan = autoEvent?.spans?.find(s => s.op === APP_START_COLD_OP);
-    expect(autoSpan?.timestamp).toBeCloseTo(autoTimeSeconds, 1);
 
-    // Simulate the native layer returning has_fetched: true after the first fetch.
-    // _appLoaded() must use the cached response to avoid bailing out.
-    mockFunction(NATIVE.fetchNativeAppStart).mockResolvedValue({
-      type: 'cold' as const,
-      app_start_timestamp_ms: appStartTimeMilliseconds,
-      has_fetched: true,
-      spans: [],
-    });
+    // No transaction sent yet — the standalone send is deferred
+    expect(standaloneClient.eventQueue.length).toBe(0);
 
-    // Now call appLoaded() with a later timestamp
+    // Now call appLoaded() with a later timestamp — this cancels the deferred
+    // auto-capture send and sends only one transaction with the manual timestamp.
     const manualTimeSeconds = autoTimeSeconds + 2;
     mockFunction(timestampInSeconds).mockReturnValue(manualTimeSeconds);
     await _appLoaded();
     await new Promise(resolve => setTimeout(resolve, 0));
 
-    // appLoaded() should have sent a second standalone transaction with the manual timestamp
-    expect(standaloneClient.eventQueue.length).toBe(2);
-    const manualEvent = standaloneClient.eventQueue[1];
+    // Only one transaction should be sent — the manual one
+    expect(standaloneClient.eventQueue.length).toBe(1);
+    const manualEvent = standaloneClient.eventQueue[0];
     const manualSpan = manualEvent?.spans?.find(s => s.op === APP_START_COLD_OP);
     expect(manualSpan).toBeDefined();
     expect(manualSpan?.timestamp).toBeCloseTo(manualTimeSeconds, 1);
     expect(manualSpan?.start_timestamp).toBeCloseTo(appStartTimeMilliseconds / 1000, 1);
     expect(manualSpan?.origin).toBe(SPAN_ORIGIN_MANUAL_APP_START);
   });
 
+  it('sends deferred standalone transaction when appLoaded() is not called', async () => {
+    jest.useFakeTimers();
+
+    getCurrentScope().clear();
+    getIsolationScope().clear();
+    getGlobalScope().clear();
+
+    const [, appStartTimeMilliseconds] = mockAppStart({ cold: true });
+
+    const integration = appStartIntegration({ standalone: true }) as AppStartIntegrationTest;
+    const standaloneClient = new TestClient({
+      ...getDefaultTestClientOptions(),
+      enableAppStartTracking: true,
+      tracesSampleRate: 1.0,
+    });
+    setCurrentClient(standaloneClient);
+    integration.setup(standaloneClient);
+    standaloneClient.addIntegration(integration);
+
+    const autoTimeSeconds = Date.now() / 1000;
+    mockFunction(timestampInSeconds).mockReturnValue(autoTimeSeconds);
+    await _captureAppStart({ isManual: false });
+
+    // No transaction yet — deferred
+    expect(standaloneClient.eventQueue.length).toBe(0);
+
+    // Advance timers to fire the deferred send, then switch to real timers
+    // so the async captureStandaloneAppStart() can complete naturally.
+    jest.runAllTimers();
+    jest.useRealTimers();
+    // Flush async event processing (captureStandaloneAppStart has multiple await steps)
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    expect(standaloneClient.eventQueue.length).toBe(1);
+    const autoEvent = standaloneClient.eventQueue[0];
+    const autoSpan = autoEvent?.spans?.find(s => s.op === APP_START_COLD_OP);
+    expect(autoSpan).toBeDefined();
+    expect(autoSpan?.timestamp).toBeCloseTo(autoTimeSeconds, 1);
+    expect(autoSpan?.start_timestamp).toBeCloseTo(appStartTimeMilliseconds / 1000, 1);
+  });
+
   it('allows auto-capture again after isAppLoadedManuallyInvoked is reset', async () => {
     getCurrentScope().clear();
     getIsolationScope().clear();