feat(android): Add conditional exporters for logs and traces

This change introduces conditional exporters for both logs and spans on the Android SDK. These new exporters, `ConditionalLogRecordExporter` and `ConditionalSpanExporter`, allow for separate filtering of normal application telemetry versus error and crash reports.

Key changes:
-   Added `ConditionalLogRecordExporter.kt` to filter logs, distinguishing between normal logs and crash reports from OpenTelemetry's CrashReporter.
-   Added `ConditionalSpanExporter.kt` to filter spans, distinguishing between normal traces and error spans created by `recordError`.
-   Updated `InstrumentationManager.kt` to use these conditional exporters, enabling independent control over sending normal logs/traces and error/crash data based on the configuration options (`disableLogs`, `disableTraces`, `disableErrorTracking`).

Author: agrognetti

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

@@ -0,0 +1,43 @@
+package com.launchdarkly.observability.client
+
+import io.opentelemetry.sdk.common.CompletableResultCode
+import io.opentelemetry.sdk.logs.data.LogRecordData
+import io.opentelemetry.sdk.logs.export.LogRecordExporter
+
+/**
+ * A log record exporter that conditionally forwards logs based on their source.
+ * This allows different filtering rules for crashes vs normal logs.
+ *
+ * @property delegate The underlying exporter to forward logs to
+ * @property allowNormalLogs Whether to allow normal application logs
+ * @property allowCrashes Whether to allow crash logs from OpenTelemetry's CrashReporter
+ */
+class ConditionalLogRecordExporter(
+    private val delegate: LogRecordExporter,
+    private val allowNormalLogs: Boolean,
+    private val allowCrashes: Boolean
+) : LogRecordExporter {
+    
+    override fun export(logs: Collection<LogRecordData>): CompletableResultCode {
+        val filteredLogs = logs.filter { logRecord ->
+            // Check if this is a crash log (from OpenTelemetry's CrashReporter)
+            val instrumentationScopeName = logRecord.instrumentationScopeInfo.name
+            val isCrashLog = instrumentationScopeName == "io.opentelemetry.crash"
+            
+            when {
+                isCrashLog -> allowCrashes
+                else -> allowNormalLogs
+            }
+        }
+        
+        return if (filteredLogs.isNotEmpty()) {
+            delegate.export(filteredLogs)
+        } else {
+            CompletableResultCode.ofSuccess()
+        }
+    }
+    
+    override fun flush(): CompletableResultCode = delegate.flush()
+    
+    override fun shutdown(): CompletableResultCode = delegate.shutdown()
+}

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

@@ -0,0 +1,43 @@
+package com.launchdarkly.observability.client
+
+import io.opentelemetry.sdk.common.CompletableResultCode
+import io.opentelemetry.sdk.trace.data.SpanData
+import io.opentelemetry.sdk.trace.export.SpanExporter
+
+/**
+ * A span exporter that conditionally forwards spans based on their source.
+ * This allows different filtering rules for error spans vs normal spans.
+ *
+ * @property delegate The underlying exporter to forward spans to
+ * @property allowNormalSpans Whether to allow normal application spans
+ * @property allowErrorSpans Whether to allow error spans created by recordError method
+ */
+class ConditionalSpanExporter(
+    private val delegate: SpanExporter,
+    private val allowNormalSpans: Boolean,
+    private val allowErrorSpans: Boolean
+) : SpanExporter {
+    
+    override fun export(spans: Collection<SpanData>): CompletableResultCode {
+        val filteredSpans = spans.filter { spanData ->
+            // Check if this is an error span created by recordError method
+            val spanName = spanData.name
+            val isErrorSpan = spanName == InstrumentationManager.ERROR_SPAN_NAME
+            
+            when {
+                isErrorSpan -> allowErrorSpans
+                else -> allowNormalSpans
+            }
+        }
+        
+        return if (filteredSpans.isNotEmpty()) {
+            delegate.export(filteredSpans)
+        } else {
+            CompletableResultCode.ofSuccess()
+        }
+    }
+    
+    override fun flush(): CompletableResultCode = delegate.flush()
+    
+    override fun shutdown(): CompletableResultCode = delegate.shutdown()
+}

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

@@ -66,8 +66,7 @@ class InstrumentationManager(
         private const val LOGS_PATH = "/v1/logs"
         private const val TRACES_PATH = "/v1/traces"
         private const val INSTRUMENTATION_SCOPE_NAME = "com.launchdarkly.observability"
-
-        // Batch processor configuration constants
+        const val ERROR_SPAN_NAME = "highlight.error"
         private const val BATCH_MAX_QUEUE_SIZE = 100
         private const val BATCH_SCHEDULE_DELAY_MS = 1000L
         private const val BATCH_EXPORTER_TIMEOUT_MS = 5000L
@@ -100,14 +99,14 @@ class InstrumentationManager(
 
         otelRUM = OpenTelemetryRum.builder(application, otelRumConfig)
             .addLoggerProviderCustomizer { sdkLoggerProviderBuilder, _ ->
-                return@addLoggerProviderCustomizer if (options.disableLogs) {
+                return@addLoggerProviderCustomizer if (options.disableLogs && options.disableErrorTracking) {
                     sdkLoggerProviderBuilder
                 } else {
                     configureLoggerProvider(sdkLoggerProviderBuilder)
                 }
             }
             .addTracerProviderCustomizer { sdkTracerProviderBuilder, _ ->
-                return@addTracerProviderCustomizer if (options.disableTraces) {
+                return@addTracerProviderCustomizer if (options.disableTraces && options.disableErrorTracking) {
                     sdkTracerProviderBuilder
                 } else {
                     configureTracerProvider(sdkTracerProviderBuilder)
@@ -199,26 +198,48 @@ class InstrumentationManager(
     }
 
     private fun createLogExporter(primaryExporter: LogRecordExporter): LogRecordExporter {
+        val conditionalExporter = ConditionalLogRecordExporter(
+            delegate = primaryExporter,
+            allowNormalLogs = !options.disableLogs,
+            allowCrashes = !options.disableErrorTracking
+        )
+        
         return if (options.debug) {
-            val exporters = mutableListOf(primaryExporter, DebugLogExporter(logger))
+            val debugExporter = ConditionalLogRecordExporter(
+                delegate = DebugLogExporter(logger),
+                allowNormalLogs = !options.disableLogs,
+                allowCrashes = !options.disableErrorTracking
+            )
+            val exporters = mutableListOf<LogRecordExporter>(conditionalExporter, debugExporter)
             inMemoryLogExporter = InMemoryLogRecordExporter.create().also { exporters.add(it) }
 
             val compositeExporter = CompositeLogExporter(exporters)
             SamplingLogExporter(compositeExporter, customSampler)
         } else {
-            SamplingLogExporter(primaryExporter, customSampler)
+            SamplingLogExporter(conditionalExporter, customSampler)
         }
     }
 
     private fun createSpanExporter(primaryExporter: SpanExporter): SpanExporter {
+        val conditionalExporter = ConditionalSpanExporter(
+            delegate = primaryExporter,
+            allowNormalSpans = !options.disableTraces,
+            allowErrorSpans = !options.disableErrorTracking
+        )
+        
         return if (options.debug) {
-            val exporters = mutableListOf(primaryExporter, DebugSpanExporter(logger))
+            val debugExporter = ConditionalSpanExporter(
+                delegate = DebugSpanExporter(logger),
+                allowNormalSpans = !options.disableTraces,
+                allowErrorSpans = !options.disableErrorTracking
+            )
+            val exporters = mutableListOf<SpanExporter>(conditionalExporter, debugExporter)
             inMemorySpanExporter = InMemorySpanExporter.create().also { exporters.add(it) }
 
             val compositeExporter = CompositeSpanExporter(exporters)
             SamplingTraceExporter(compositeExporter, customSampler)
         } else {
-            SamplingTraceExporter(primaryExporter, customSampler)
+            SamplingTraceExporter(conditionalExporter, customSampler)
         }
     }
 
@@ -313,7 +334,7 @@ class InstrumentationManager(
     fun recordError(error: Error, attributes: Attributes) {
         if(!options.disableErrorTracking){
             val span = otelTracer
-                .spanBuilder("highlight.error")
+                .spanBuilder(ERROR_SPAN_NAME)
                 .setParent(Context.current().with(Span.current()))
                 .startSpan()