fix(android): Prevent duplicate standalone app start measurements

Require the app-start pending flag even when standalone app-start transactions bypass foreground checks. Preserve completed non-activity app-start timings so fallback resolution does not overwrite stopped spans.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: buenaflor

sentry-android-core/api/sentry-android-core.api

@@ -775,6 +775,7 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public fun setClassLoadedUptimeMs (J)V
 	public fun setOnNoActivityStartedListener (Lio/sentry/android/core/performance/AppStartMetrics$OnNoActivityStartedListener;)V
 	public fun shouldSendStartMeasurements ()Z
+	public fun shouldSendStartMeasurements (Z)Z
 }
 
 public final class io/sentry/android/core/performance/AppStartMetrics$AppStartType : java/lang/Enum {

sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java

@@ -85,13 +85,13 @@ public SentryEvent process(@NotNull SentryEvent event, @NotNull Hint hint) {
       // the app start measurement is only sent once and only if the transaction has
       // the app.start span, which is automatically created by the SDK.
       if (hasAppStartSpan(transaction)) {
-        // For non-activity starts, appLaunchedInForeground is false, so
-        // shouldSendStartMeasurements() would return false. We still want to attach child spans.
+        // For non-activity starts, appLaunchedInForeground is false, so standalone app start
+        // transactions bypass only the foreground check, not the duplicate-send guard.
         final @Nullable SpanContext traceContext = transaction.getContexts().getTrace();
         final boolean isStandaloneAppStartTxn =
             traceContext != null && STANDALONE_APP_START_OP.equals(traceContext.getOperation());
 
-        if (appStartMetrics.shouldSendStartMeasurements() || isStandaloneAppStartTxn) {
+        if (appStartMetrics.shouldSendStartMeasurements(isStandaloneAppStartTxn)) {
           final @NotNull TimeSpan appStartTimeSpan =
               isStandaloneAppStartTxn
                   ? appStartMetrics.getAppStartTimeSpanDirect()

sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java

@@ -228,8 +228,13 @@ public void onAppStartSpansSent() {
     activityLifecycles.clear();
   }
 
+  public boolean shouldSendStartMeasurements(final boolean ignoreForegroundCheck) {
+    return shouldSendStartMeasurements
+        && (ignoreForegroundCheck || appLaunchedInForeground.getValue());
+  }
+
   public boolean shouldSendStartMeasurements() {
-    return shouldSendStartMeasurements && appLaunchedInForeground.getValue();
+    return shouldSendStartMeasurements(false);
   }
 
   public long getClassLoadedUptimeMs() {
@@ -502,7 +507,9 @@ private void resolveNonActivityAppStartEndTime() {
 
   private void stopNonActivityAppStartAt(final long stopUptimeMs) {
     if (appStartSpan.hasStarted()) {
-      appStartSpan.setStoppedAt(stopUptimeMs);
+      if (appStartSpan.hasNotStopped()) {
+        appStartSpan.setStoppedAt(stopUptimeMs);
+      }
     } else if (sdkInitTimeSpan.hasStarted() && sdkInitTimeSpan.hasNotStopped()) {
       sdkInitTimeSpan.setStoppedAt(stopUptimeMs);
     }

sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt

@@ -206,6 +206,23 @@ class PerformanceAndroidEventProcessorTest {
     assertTrue(tr2.measurements.isEmpty())
   }
 
+  @Test
+  fun `do not add standalone app start metric twice`() {
+    val sut = fixture.getSut()
+
+    setStandaloneColdAppStartMetrics()
+
+    var tr1 = getTransaction(AppStartType.COLD)
+    tr1 = sut.process(tr1, Hint())
+
+    var tr2 = getTransaction(AppStartType.COLD)
+    tr2 = sut.process(tr2, Hint())
+
+    assertTrue(tr1.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertFalse(tr2.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertFalse(tr2.measurements.containsKey(MeasurementValue.KEY_APP_START_WARM))
+  }
+
   @Test
   fun `do not add app start metric if its not ready`() {
     val sut = fixture.getSut()
@@ -522,10 +539,10 @@ class PerformanceAndroidEventProcessorTest {
     val appStartSpan = createAppStartSpan(tr.contexts.trace!!.traceId)
     tr.spans.add(appStartSpan)
 
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
     // then the app start metrics should be attached
     tr = sut.process(tr, Hint())
-    assertFalse(appStartMetrics.shouldSendStartMeasurements())
+    assertFalse(appStartMetrics.shouldSendStartMeasurements(false))
 
     assertTrue(tr.spans.any { "application.load" == it.op })
 

sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt

@@ -175,7 +175,7 @@ class AppStartMetricsTest {
     // but no activity creation happened
     // then the app wasn't launched in foreground and nothing should be sent
     assertFalse(metrics.isAppLaunchedInForeground)
-    assertFalse(metrics.shouldSendStartMeasurements())
+    assertFalse(metrics.shouldSendStartMeasurements(false))
 
     val now = TimeUnit.MINUTES.toMillis(2) + 1234567
     SystemClock.setCurrentTimeMillis(now)
@@ -185,7 +185,7 @@ class AppStartMetricsTest {
 
     // then it should restart the timespan
     assertTrue(metrics.isAppLaunchedInForeground)
-    assertTrue(metrics.shouldSendStartMeasurements())
+    assertTrue(metrics.shouldSendStartMeasurements(false))
     assertTrue(metrics.appStartTimeSpan.hasStarted())
     assertEquals(now, metrics.appStartTimeSpan.startUptimeMs)
     assertFalse(metrics.applicationOnCreateTimeSpan.hasStarted())
@@ -288,6 +288,24 @@ class AppStartMetricsTest {
     assertEquals(100, metrics.appStartTimeSpan.durationMs)
   }
 
+  @Test
+  fun `resolveNonActivityAppStartEndTime does not overwrite stopped appStartTimeSpan`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(100)
+      setStoppedAt(150)
+    }
+    metrics.applicationOnCreateTimeSpan.apply {
+      setStartedAt(120)
+      setStoppedAt(200)
+    }
+
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(50, metrics.appStartTimeSpan.durationMs)
+  }
+
   @Test
   fun `getAppStartTimeSpanDirect falls back to sdkInitTimeSpan when appStartSpan has not stopped`() {
     val metrics = AppStartMetrics.getInstance()
@@ -461,11 +479,11 @@ class AppStartMetricsTest {
     val appStartMetrics = AppStartMetrics.getInstance()
     appStartMetrics.addActivityLifecycleTimeSpans(mock())
     appStartMetrics.contentProviderOnCreateTimeSpans.add(mock())
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
     appStartMetrics.onAppStartSpansSent()
     assertTrue(appStartMetrics.activityLifecycleTimeSpans.isEmpty())
     assertTrue(appStartMetrics.contentProviderOnCreateTimeSpans.isEmpty())
-    assertFalse(appStartMetrics.shouldSendStartMeasurements())
+    assertFalse(appStartMetrics.shouldSendStartMeasurements(false))
   }
 
   @Test
@@ -479,18 +497,18 @@ class AppStartMetricsTest {
 
     // then the app start type should be cold and measurements should be sent
     assertEquals(AppStartMetrics.AppStartType.COLD, appStartMetrics.appStartType)
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
 
     // when the activity gets destroyed
     appStartMetrics.onAppStartSpansSent()
-    assertFalse(appStartMetrics.shouldSendStartMeasurements())
+    assertFalse(appStartMetrics.shouldSendStartMeasurements(false))
 
     appStartMetrics.onActivityDestroyed(activity0)
 
     // then it should reset sending the measurements for the next warm activity
     appStartMetrics.onActivityCreated(mock<Activity>(), mock<Bundle>())
     assertEquals(AppStartMetrics.AppStartType.WARM, appStartMetrics.appStartType)
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
   }
 
   @Test
@@ -882,7 +900,7 @@ class AppStartMetricsTest {
     whenever(firstActivity.isChangingConfigurations).thenReturn(false)
     metrics.onActivityCreated(firstActivity, null)
     assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
-    assertTrue(metrics.shouldSendStartMeasurements())
+    assertTrue(metrics.shouldSendStartMeasurements(false))
     metrics.onAppStartSpansSent()
     waitForMainLooperIdle()
 
@@ -895,15 +913,15 @@ class AppStartMetricsTest {
     metrics.onActivityCreated(secondActivity, null)
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
     assertTrue(metrics.isAppLaunchedInForeground)
-    assertTrue(metrics.shouldSendStartMeasurements())
+    assertTrue(metrics.shouldSendStartMeasurements(false))
     metrics.onAppStartSpansSent()
 
     // Third activity - should still be warm
     SystemClock.setCurrentTimeMillis(SystemClock.uptimeMillis() + 100)
     metrics.onActivityCreated(mock<Activity>(), null)
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
     assertTrue(metrics.isAppLaunchedInForeground)
-    assertFalse(metrics.shouldSendStartMeasurements())
+    assertFalse(metrics.shouldSendStartMeasurements(false))
   }
 
   @Test