refactor: O11Y-742 - Replaced ConditionalSpanExporter with SpansSampler (#289)

## Summary
This change simplifies the trace exporting pipeline by moving the
filtering responsibility from the exporter (ConditionalSpanExporter) to
the sampler (SpansSampler), which is the more appropriate place for this
logic.

## How did you test this change?
Unit tests

## Are there any deployment considerations?
No

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Moves span filtering to an OpenTelemetry sampler (`SpansSampler`),
removes `ConditionalSpanExporter`, wires sampler into tracer provider,
and updates sampling utilities and tests.
> 
> - **Tracing/Sampling**:
> - **Sampler Integration**: Set tracer provider sampler to new
`SpansSampler` in `InstrumentationManager`, controlling normal vs error
spans via options.
> - **Exporter Pipeline**: Remove `ConditionalSpanExporter` usage;
`createSpanExporter` now directly wraps base exporter with
`SamplingTraceExporter`.
> - **API Adjustments**: Update `spanProcessor` type to `SpanProcessor`.
> - **Sampling Utilities**:
> - Update `sampleSpans` to use `SpanData.spanId`/`parentSpanId` and
adjust cloning to merge attributes.
> - **Tests**:
> - Add `SpansSamplerTest` covering sampling decisions and description.
>   - Remove `ConditionalSpanExporterTest`.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
f634859. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: agrognetti

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/client/ConditionalSpanExporter.kt

@@ -11,6 +11,7 @@ import com.launchdarkly.observability.sampling.ExportSampler
 import com.launchdarkly.observability.sampling.SamplingConfig
 import com.launchdarkly.observability.sampling.SamplingLogProcessor
 import com.launchdarkly.observability.sampling.SamplingTraceExporter
+import com.launchdarkly.observability.sampling.SpansSampler
 import com.launchdarkly.observability.coroutines.DispatcherProviderHolder
 import io.opentelemetry.android.OpenTelemetryRum
 import io.opentelemetry.android.config.OtelRumConfig
@@ -41,6 +42,7 @@ import io.opentelemetry.sdk.metrics.export.MetricExporter
 import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader
 import io.opentelemetry.sdk.resources.Resource
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder
+import io.opentelemetry.sdk.trace.SpanProcessor
 import io.opentelemetry.sdk.trace.export.BatchSpanProcessor
 import io.opentelemetry.sdk.trace.export.SpanExporter
 import kotlinx.coroutines.CoroutineScope
@@ -73,7 +75,7 @@ class InstrumentationManager(
     private val graphqlClient = GraphQLClient(options.backendUrl)
     private val samplingApiService = SamplingApiService(graphqlClient)
     private var telemetryInspector: TelemetryInspector? = null
-    private var spanProcessor: BatchSpanProcessor? = null
+    private var spanProcessor: SpanProcessor? = null
     private var logProcessor: LogRecordProcessor? = null
     private var metricsReader: PeriodicMetricReader? = null
     private var launchTimeInstrumentation: LaunchTimeInstrumentation? = null
@@ -169,7 +171,14 @@ class InstrumentationManager(
 
     private fun configureTracerProvider(sdkTracerProviderBuilder: SdkTracerProviderBuilder): SdkTracerProviderBuilder {
         val primarySpanExporter = createOtlpSpanExporter()
-        sdkTracerProviderBuilder.setResource(resources)
+        sdkTracerProviderBuilder
+            .setResource(resources)
+            .setSampler(
+                SpansSampler(
+                    allowNormalSpans = !options.disableTraces,
+                    allowErrorSpans = !options.disableErrorTracking
+                )
+            )
 
         val finalExporter = createSpanExporter(primarySpanExporter)
         val processor = createBatchSpanProcessor(finalExporter)
@@ -218,13 +227,7 @@ class InstrumentationManager(
             primaryExporter
         }
 
-        val conditionalExporter = ConditionalSpanExporter(
-            delegate = baseExporter,
-            allowNormalSpans = !options.disableTraces,
-            allowErrorSpans = !options.disableErrorTracking
-        )
-
-        return SamplingTraceExporter(conditionalExporter, customSampler)
+        return SamplingTraceExporter(baseExporter, customSampler)
     }
 
     private fun createMetricExporter(primaryExporter: MetricExporter): MetricExporter {

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/client/InstrumentationManager.kt

@@ -20,19 +20,19 @@ fun sampleSpans(
     // The first pass we sample items which are directly impacted by a sampling decision.
     // We also build a map of children spans by parent span id, which allows us to quickly traverse the span tree.
     for (item in items) {
-        item.parentSpanContext?.spanId?.let { parentSpanId ->
+        item.parentSpanId?.let { parentSpanId ->
             childrenByParentId.getOrPut(parentSpanId) { mutableListOf() }
-                .add(item.spanContext.spanId)
+                .add(item.spanId)
         }
         val sampleResult = sampler.sampleSpan(item)
         if (sampleResult.sample) {
             if (sampleResult.attributes != null) {
-                spanById[item.spanContext.spanId] = cloneSpanDataWithAttributes(item, sampleResult.attributes)
+                spanById[item.spanId] = cloneSpanDataWithAttributes(item, sampleResult.attributes)
             } else {
-                spanById[item.spanContext.spanId] = item
+                spanById[item.spanId] = item
             }
         } else {
-            omittedSpansIds.addLast(item.spanContext.spanId)
+            omittedSpansIds.addLast(item.spanId)
         }
     }
 

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/sampling/SampleSpans.kt

@@ -0,0 +1,46 @@
+package com.launchdarkly.observability.sampling
+
+import com.launchdarkly.observability.client.InstrumentationManager
+import io.opentelemetry.api.common.Attributes
+import io.opentelemetry.api.trace.SpanKind
+import io.opentelemetry.context.Context
+import io.opentelemetry.sdk.trace.data.LinkData
+import io.opentelemetry.sdk.trace.samplers.Sampler
+import io.opentelemetry.sdk.trace.samplers.SamplingResult
+
+/**
+ * OpenTelemetry sampler that differentiates between normal spans and error spans.
+ *
+ * The constructor flags determine whether each span category is recorded or not.
+ */
+class SpansSampler(
+    private val allowNormalSpans: Boolean,
+    private val allowErrorSpans: Boolean
+) : Sampler {
+
+    override fun shouldSample(
+        parentContext: Context,
+        traceId: String,
+        spanName: String,
+        spanKind: SpanKind,
+        attributes: Attributes,
+        parentLinks: List<LinkData>
+    ): SamplingResult {
+        return if (shouldRecordSpan(spanName)) {
+            SamplingResult.recordAndSample()
+        } else {
+            SamplingResult.drop()
+        }
+    }
+
+    override fun getDescription(): String = "LaunchDarklySpansSampler"
+
+    private fun shouldRecordSpan(spanName: String): Boolean {
+        val isErrorSpan = spanName == InstrumentationManager.ERROR_SPAN_NAME
+
+        return when {
+            isErrorSpan -> allowErrorSpans
+            else -> allowNormalSpans
+        }
+    }
+}