fix(compose): retain root span cache entries synchronously to avoid a dispose/remember race

Retaining inside a DisposableEffect deferred the retain to the
effect-application phase, but Compose dispatches an outgoing
composable's onDispose before an incoming composable's
DisposableEffect in the same recomposition. Replacing a SentryTraced
call under a given scopes (e.g. during navigation) could therefore
have the outgoing call's release clear the cache before the incoming
call's retain ran, so a later SentryTraced call under the same scopes
found nothing cached and created a duplicate root span.

Retain now happens inside remember instead, which runs synchronously
during composition, before any effect-phase work for that frame -
including another SentryTraced call's dispose. Release stays in
DisposableEffect's onDispose since its timing no longer matters.

Adds a regression test that swaps which keyed SentryTraced composable
is mounted under the same scopes twice in a row, which reproduces the
duplicate span without this fix.

Author: Tabishahmad

sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeTracing.kt

@@ -124,10 +124,13 @@ public fun SentryTraced(
 ) {
   val scopes = LocalSentryScopes.current ?: Sentry.getCurrentScopes()
   val rootSpans = LocalRootSpans.current
-  DisposableEffect(rootSpans, scopes) {
-    rootSpans.retain(scopes)
-    onDispose { rootSpans.release(scopes) }
-  }
+  // Retain synchronously during composition (not inside a DisposableEffect) so it always runs
+  // before any effect-phase work for this frame, including another SentryTraced call's dispose:
+  // Compose runs the dispose of an outgoing node before the effects of an incoming one in the
+  // same recomposition, so retaining from an effect could let the shared entry's refcount hit
+  // zero (and get evicted) between an old and a new SentryTraced call sharing the same scopes.
+  remember(rootSpans, scopes) { rootSpans.retain(scopes) }
+  DisposableEffect(rootSpans, scopes) { onDispose { rootSpans.release(scopes) } }
   val parentCompositionSpan =
     getOrCreateParentSpan(rootSpans.compositionSpans, scopes, ::createCompositionParentSpan)
   val parentRenderingSpan =

sentry-compose/src/androidUnitTest/kotlin/io/sentry/compose/SentryTracedTest.kt

@@ -5,6 +5,10 @@ import android.content.ComponentName
 import androidx.activity.ComponentActivity
 import androidx.compose.foundation.layout.Box
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import androidx.test.core.app.ApplicationProvider
@@ -117,4 +121,30 @@ class SentryTracedTest {
     assertEquals(1, txB.spans.count { it.operation == "ui.compose.composition" })
     assertEquals(1, txB.spans.count { it.operation == "ui.compose" })
   }
+
+  @Test
+  fun `repeatedly replacing a traced composable under the same scopes keeps sharing the root span`() {
+    // Each swap disposes the outgoing keyed composable and mounts a new one under the same
+    // scopes within a single recomposition. Compose dispatches the outgoing composable's
+    // onDispose before the incoming one's DisposableEffect runs, so a second swap is needed to
+    // surface a root span cache that was cleared out from under a still-live retain.
+    val scopes = newTracingScopes()
+    val tx = scopes.startBoundTransaction("custom-scopes-tx")
+    var step by mutableStateOf(0)
+
+    rule.setContent {
+      CompositionLocalProvider(LocalSentryScopes provides scopes) {
+        key(step) { SentryTraced(tag = "step-$step") { Box {} } }
+      }
+    }
+    rule.waitForIdle()
+
+    step = 1
+    rule.waitForIdle()
+
+    step = 2
+    rule.waitForIdle()
+
+    assertEquals(1, tx.spans.count { it.operation == "ui.compose.composition" })
+  }
 }