fix(compose): address PR review feedback on LocalSentryScopes root span caching

Key scopes weakly in RootSpans so custom IScopes instances (and their
cached parent spans) can be garbage collected once nothing else holds
a reference, instead of being pinned for the lifetime of the root
Composition. Also stop permanently caching a null parent span when no
transaction is bound yet, so a later transaction on the same scopes is
still picked up.

Addresses review feedback from sentry-review-bot and cursor bugbot on
#5838.

Author: Tabishahmad

CHANGELOG.md

@@ -2,11 +2,6 @@
 
 ## Unreleased
 
-### Improvements
-
-- Skip building Android manifest metadata debug log messages when debug logging is disabled, reducing allocations during SDK init ([#5790](https://github.com/getsentry/sentry-java/pull/5790))
-## Unreleased
-
 ### Features
 
 - Add `LocalSentryScopes` to `sentry-compose`, allowing `SentryTraced` to trace against a custom `IScopes` instance instead of always defaulting to `Sentry.getCurrentScopes()` ([#5838](https://github.com/getsentry/sentry-java/pull/5838))

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

@@ -15,6 +15,7 @@ import io.sentry.ISpan
 import io.sentry.Sentry
 import io.sentry.SpanOptions
 import io.sentry.compose.SentryModifier.sentryTag
+import java.util.WeakHashMap
 
 private const val OP_PARENT_COMPOSITION = "ui.compose.composition"
 private const val OP_COMPOSE = "ui.compose"
@@ -67,10 +68,22 @@ private fun createRenderingParentSpan(scopes: IScopes): ImmutableHolder<ISpan?>
   )
 
 private class RootSpans {
-  val compositionSpans = HashMap<IScopes, ImmutableHolder<ISpan?>>()
-  val renderingSpans = HashMap<IScopes, ImmutableHolder<ISpan?>>()
+  // Weakly keyed so scopes instances that are no longer referenced elsewhere (e.g. a short-lived
+  // custom scopes provided via LocalSentryScopes for a finished screen/session) can be garbage
+  // collected instead of being pinned here for the lifetime of the root Composition.
+  val compositionSpans = WeakHashMap<IScopes, ImmutableHolder<ISpan?>>()
+  val renderingSpans = WeakHashMap<IScopes, ImmutableHolder<ISpan?>>()
 }
 
+private fun getOrCreateParentSpan(
+  map: MutableMap<IScopes, ImmutableHolder<ISpan?>>,
+  scopes: IScopes,
+  create: (IScopes) -> ImmutableHolder<ISpan?>,
+): ImmutableHolder<ISpan?> =
+  // Only cache the holder once it actually contains a span; a null result (no transaction bound
+  // to the scopes yet) is recomputed on the next call so a later transaction is still picked up.
+  map[scopes] ?: create(scopes).also { if (it.item != null) map[scopes] = it }
+
 // Cached once per Composition and shared by every SentryTraced call within it, mirroring the
 // old eagerly-computed `compositionLocalOf { ... }` default (which Compose resolves once and
 // reuses for every `.current` read that has no ancestor Provider, sibling or not). Keyed per
@@ -88,9 +101,9 @@ public fun SentryTraced(
   val scopes = LocalSentryScopes.current
   val rootSpans = LocalRootSpans.current
   val parentCompositionSpan =
-    rootSpans.compositionSpans.getOrPut(scopes) { createCompositionParentSpan(scopes) }
+    getOrCreateParentSpan(rootSpans.compositionSpans, scopes, ::createCompositionParentSpan)
   val parentRenderingSpan =
-    rootSpans.renderingSpans.getOrPut(scopes) { createRenderingParentSpan(scopes) }
+    getOrCreateParentSpan(rootSpans.renderingSpans, scopes, ::createRenderingParentSpan)
 
   val compositionSpan =
     parentCompositionSpan.item?.startChild(OP_COMPOSE, tag)?.apply {