fix(compose): Honor ignored origins in SentryTraced spans

Fix a bug where we set span origins for SentryTraced after their creation via the span context, resulting in our ignore-span-origins logic not being able to see them and spans being produced when they should have been ignored / suppressed.

What was happening?

SentryTracer checks `ignoredSpanOrigins` during span creation, before the returned span can be mutated:

```java
if (SpanUtils.isIgnored(scopes.getOptions().getIgnoredSpanOrigins(), spanOptions.getOrigin())) {
  return NoOpSpan.getInstance();
}
```

That check reads SpanOptions.origin, not the SpanContext.origin we were setting after creation.

So if a host app did this...

```kotlin
options.setIgnoredSpanOrigins(listOf("auto.ui.jetpack_compose"))
```

...it would no-op and the Compose spans were created nonetheless.

The issue affected both levels of the SentryTraced span hierarchy (ie, both parent spans and child spans).

Author: 0xadam-brown

CHANGELOG.md

@@ -4,7 +4,8 @@
 
 ### Fixes
 
-`SentryTraced` now checks for its owning transaction dynamically rather than once per app process. The latter caused `SentryTraced` spans to be dropped process-wide once the original transaction finished ([#6057](https://github.com/getsentry/sentry-java/pull/6057))
+- Update `SentryTraced` so that it now honors `options.setIgnoredSpanOrigins` ([#6058](https://github.com/getsentry/sentry-java/pull/6058))
+- `SentryTraced` now checks for its owning transaction dynamically rather than once per app process. The latter caused `SentryTraced` spans to be dropped process-wide once the original transaction finished ([#6057](https://github.com/getsentry/sentry-java/pull/6057))
 
 ## 8.55.0
 

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

@@ -117,10 +117,15 @@ private fun recordCompositionSpan(
 ) {
   val parentSpan = ParentSpans.getOrCreateCompositionSpan(ownerSpan, startTimestamp) ?: return
 
-  parentSpan.startChild(OP_COMPOSITION_CHILD, tag, startTimestamp).apply {
-    spanContext.origin = OP_TRACE_ORIGIN
-    finish(null, endTimestamp)
-  }
+  parentSpan
+    .startChild(
+      OP_COMPOSITION_CHILD,
+      tag,
+      startTimestamp,
+      Instrumenter.SENTRY,
+      SpanOptions().apply { origin = OP_TRACE_ORIGIN },
+    )
+    .run { finish(null, endTimestamp) }
 }
 
 private fun recordRenderSpan(
@@ -131,10 +136,15 @@ private fun recordRenderSpan(
 ) {
   val parentSpan = ParentSpans.getOrCreateRenderSpan(ownerSpan, startTimestamp) ?: return
 
-  parentSpan.startChild(OP_RENDER_CHILD, tag, startTimestamp).apply {
-    spanContext.origin = OP_TRACE_ORIGIN
-    finish(null, endTimestamp)
-  }
+  parentSpan
+    .startChild(
+      OP_RENDER_CHILD,
+      tag,
+      startTimestamp,
+      Instrumenter.SENTRY,
+      SpanOptions().apply { origin = OP_TRACE_ORIGIN },
+    )
+    .run { finish(null, endTimestamp) }
 }
 
 /**
@@ -220,6 +230,7 @@ private class ParentSpans {
         startTimestamp,
         Instrumenter.SENTRY,
         SpanOptions().apply {
+          origin = OP_TRACE_ORIGIN
           isTrimStart = true
           isTrimEnd = true
           isIdle = true
@@ -229,8 +240,6 @@ private class ParentSpans {
     if (parentSpan.dropsChildSpans) {
       return null
     }
-
-    parentSpan.spanContext.origin = OP_TRACE_ORIGIN
     setCached(WeakReference(parentSpan))
     return parentSpan
   }

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

@@ -128,6 +128,26 @@ class SentryTracedTest {
     assertThat(tx.countSpans(OP_RENDER)).isEqualTo(0)
   }
 
+  @Test
+  fun `does not create spans when compose origin is ignored`() {
+    val tx =
+      initSentryAndStartTransaction("tx") { options ->
+        options.setIgnoredSpanOrigins(listOf(OP_TRACE_ORIGIN))
+      }
+
+    rule.setContent {
+      SentryTraced(tag = "product_info") { Box(Modifier.size(1.dp).testTag("content")) }
+    }
+    rule.waitForIdle()
+    drawContent()
+
+    rule.onNodeWithTag("content").assertExists()
+    assertThat(tx.countSpans(OP_PARENT_COMPOSITION)).isEqualTo(0)
+    assertThat(tx.countSpans(OP_COMPOSE)).isEqualTo(0)
+    assertThat(tx.countSpans(OP_PARENT_RENDER)).isEqualTo(0)
+    assertThat(tx.countSpans(OP_RENDER)).isEqualTo(0)
+  }
+
   @Test
   fun `sibling traced composables with the same owner share the composition parent`() {
     val tx = initSentryAndStartTransaction("tx")
@@ -381,13 +401,17 @@ class SentryTracedTest {
     assertThat(renderingTx.countSpans(OP_RENDER)).isEqualTo(0)
   }
 
-  private fun initSentryAndStartTransaction(name: String): ITransaction {
+  private fun initSentryAndStartTransaction(
+    name: String,
+    configureOptions: (SentryOptions) -> Unit = {},
+  ): ITransaction {
     lateinit var tx: ITransaction
     rule.runOnUiThread {
       Sentry.init(
         { options: SentryOptions ->
           options.dsn = "https://key@sentry.io/proj"
           options.tracesSampleRate = 1.0
+          configureOptions(options)
         },
         true,
       )