fix(extend-app-start): Record the extended end time independently of span state

getExtendedEndTime() read span.isFinished(), but finishing the extended span
completes the waitForChildren transaction and runs the event processor
re-entrantly within finishExtendedAppStart(), before the span's finished flag
is set. The processor then saw an unfinished span and dropped the app start
measurement. Capture the end time before finishing the span instead.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: buenaflor

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

@@ -39,6 +39,7 @@ public interface ExtendAppStartListener {
   private @Nullable ExtendAppStartListener extendAppStartListener;
   private @Nullable ISpan extendedSpan;
   private @Nullable ITransaction extendedTransaction;
+  private @Nullable SentryDate extendedEndDate;
 
   public AppStartExtension(final @NotNull AppStartMetrics metrics) {
     this.metrics = metrics;
@@ -83,7 +84,13 @@ public void finishExtendedAppStart() {
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
       final @Nullable ISpan span = extendedSpan;
       if (span != null && !span.isFinished()) {
-        span.finish(SpanStatus.OK);
+        // Capture the end time before finishing the span. Finishing the last child of a
+        // waitForChildren transaction completes it and runs the event processor re-entrantly,
+        // within this call, before span.isFinished() flips. Reading the span back there would see
+        // an unfinished span, so we record the end here instead.
+        final @NotNull SentryDate now = AndroidDateUtils.getCurrentSentryDateTime();
+        extendedEndDate = now;
+        span.finish(SpanStatus.OK, now);
       }
     }
   }
@@ -116,23 +123,17 @@ public void finishTransaction(final @NotNull SentryDate endTimestamp) {
 
   public @Nullable SentryDate getExtendedEndTime() {
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
-      final @Nullable ISpan span = extendedSpan;
-      if (span == null || !span.isFinished()) {
-        return null;
-      }
-      // A deadline timeout would report an artificially inflated duration; suppress the vital
-      // instead.
-      if (span.getStatus() == SpanStatus.DEADLINE_EXCEEDED) {
-        return null;
-      }
-      return span.getFinishDate();
+      // Set only by an explicit finishExtendedAppStart(); stays null on a deadline timeout, which
+      // suppresses the vital so we never report an artificially inflated duration.
+      return extendedEndDate;
     }
   }
 
   public void clear() {
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
       extendedSpan = null;
       extendedTransaction = null;
+      extendedEndDate = null;
     }
   }
 }

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

@@ -5,18 +5,22 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.ISpan
 import io.sentry.ITransaction
 import io.sentry.NoOpSpan
+import io.sentry.SentryDate
 import io.sentry.SentryNanotimeDate
 import io.sentry.SpanStatus
 import io.sentry.android.core.performance.AppStartMetrics
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
@@ -104,12 +108,14 @@ class AppStartExtensionTest {
   }
 
   @Test
-  fun `finishExtendedAppStart finishes the extended span`() {
+  fun `finishExtendedAppStart finishes the extended span at the captured end`() {
     val ext = extension(windowOpen = true)
     val (_, span) = ext.registerHandOver()
     ext.extendAppStart()
     ext.finishExtendedAppStart()
-    verify(span).finish(SpanStatus.OK)
+    val dateCaptor = argumentCaptor<SentryDate>()
+    verify(span).finish(eq(SpanStatus.OK), dateCaptor.capture())
+    assertSame(dateCaptor.firstValue, ext.extendedEndTime)
   }
 
   @Test
@@ -176,16 +182,26 @@ class AppStartExtensionTest {
   }
 
   @Test
-  fun `getExtendedEndTime returns the finish date on a user finish`() {
+  fun `getExtendedEndTime returns the captured end after a user finish`() {
+    val ext = extension(windowOpen = true)
+    val (_, span) = ext.registerHandOver()
+    ext.extendAppStart()
+    ext.finishExtendedAppStart()
+    assertNotNull(ext.extendedEndTime)
+  }
+
+  @Test
+  fun `getExtendedEndTime returns the end even when the span still reports unfinished`() {
+    // Reproduces the waitForChildren reentrancy: finishing the extended span completes the
+    // transaction and runs the event processor within finishExtendedAppStart(), before the span's
+    // isFinished() flips. getExtendedEndTime() must not depend on the span's state.
     val ext = extension(windowOpen = true)
-    val finishDate = SentryNanotimeDate()
     val span = mock<ISpan>()
-    whenever(span.isFinished).thenReturn(true)
-    whenever(span.status).thenReturn(SpanStatus.OK)
-    whenever(span.finishDate).thenReturn(finishDate)
+    whenever(span.isFinished).thenReturn(false)
     ext.registerHandOver(span = span)
     ext.extendAppStart()
-    assertSame(finishDate, ext.extendedEndTime)
+    ext.finishExtendedAppStart()
+    assertNotNull(ext.extendedEndTime)
   }
 
   @Test