tweaking telemetry inspector usage for testing

Author: tanderson-ld

e2e/android/app/src/test/java/com/example/androidobservability/DisablingConfigOptionsE2ETest.kt

@@ -2,18 +2,17 @@ package com.example.androidobservability
 
 import android.app.Application
 import androidx.test.core.app.ApplicationProvider
+import com.example.androidobservability.TestUtils.TelemetryType
 import com.example.androidobservability.TestUtils.waitForTelemetryData
+import com.launchdarkly.observability.api.Options
 import com.launchdarkly.observability.interfaces.Metric
 import com.launchdarkly.observability.sdk.LDObserve
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.logs.Severity
-import com.example.androidobservability.TestUtils.TelemetryType
-import com.launchdarkly.observability.api.Options
 import junit.framework.TestCase.assertEquals
 import junit.framework.TestCase.assertFalse
 import junit.framework.TestCase.assertNotNull
-import junit.framework.TestCase.assertNull
 import junit.framework.TestCase.assertTrue
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -96,7 +95,6 @@ class DisablingConfigOptionsE2ETest {
         LDObserve.flush()
         waitForTelemetryData(telemetryInspector = application.telemetryInspector, telemetryType = TelemetryType.METRICS)
 
-        assertNull(application.telemetryInspector?.metricExporter)
         assertFalse(requestsContainsUrl(metricsUrl))
     }
 
@@ -110,7 +108,6 @@ class DisablingConfigOptionsE2ETest {
         LDObserve.flush()
         waitForTelemetryData(telemetryInspector = application.telemetryInspector, telemetryType = TelemetryType.METRICS)
 
-        assertNotNull(application.telemetryInspector?.metricExporter)
         assertTrue(requestsContainsUrl(metricsUrl))
     }
 

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

@@ -38,9 +38,6 @@ import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder
 import io.opentelemetry.sdk.metrics.export.MetricExporter
 import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader
 import io.opentelemetry.sdk.resources.Resource
-import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter
-import io.opentelemetry.sdk.testing.exporter.InMemoryMetricExporter
-import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder
 import io.opentelemetry.sdk.trace.export.BatchSpanProcessor
 import io.opentelemetry.sdk.trace.export.SpanExporter
@@ -74,9 +71,6 @@ class InstrumentationManager(
     private var customSampler = CustomSampler()
     private val graphqlClient = GraphQLClient(options.backendUrl)
     private val samplingApiService = SamplingApiService(graphqlClient)
-    private var inMemorySpanExporter: InMemorySpanExporter? = null
-    private var inMemoryLogExporter: InMemoryLogRecordExporter? = null
-    private var inMemoryMetricExporter: InMemoryMetricExporter? = null
     private var telemetryInspector: TelemetryInspector? = null
     private var spanProcessor: BatchSpanProcessor? = null
     private var logProcessor: LogRecordProcessor? = null
@@ -90,6 +84,7 @@ class InstrumentationManager(
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
     init {
+        initializeTelemetryInspector()
         val otelRumConfig = createOtelRumConfig()
 
         val builder = OpenTelemetryRum.builder(application, otelRumConfig)
@@ -98,7 +93,15 @@ class InstrumentationManager(
                 return@addLoggerProviderCustomizer if (options.disableLogs && options.disableErrorTracking) {
                     sdkLoggerProviderBuilder
                 } else {
-                    val processor = createLoggerProcessor(sdkLoggerProviderBuilder, customSampler, sdkKey, resources, logger, options)
+                    val processor = createLoggerProcessor(
+                        sdkLoggerProviderBuilder,
+                        customSampler,
+                        sdkKey,
+                        resources,
+                        logger,
+                        telemetryInspector,
+                        options
+                    )
                     logProcessor = processor
                     sdkLoggerProviderBuilder.addLogRecordProcessor(processor)
                 }
@@ -123,8 +126,6 @@ class InstrumentationManager(
         }
 
         otelRUM = builder.build()
-
-        initializeTelemetryInspector()
         loadSamplingConfigAsync()
 
         otelMeter = otelRUM.openTelemetry.meterProvider.get(INSTRUMENTATION_SCOPE_NAME)
@@ -198,7 +199,7 @@ class InstrumentationManager(
                 buildList {
                     add(primaryExporter)
                     add(DebugSpanExporter(logger))
-                    add(InMemorySpanExporter.create().also { inMemorySpanExporter = it })
+                    telemetryInspector?.let { add(it.spanExporter) }
                 }
             )
         } else {
@@ -220,7 +221,7 @@ class InstrumentationManager(
                 buildList {
                     add(primaryExporter)
                     add(DebugMetricExporter(logger))
-                    add(InMemoryMetricExporter.create().also { inMemoryMetricExporter = it })
+                    telemetryInspector?.let { add(it.metricExporter) }
                 }
             )
         } else {
@@ -237,7 +238,7 @@ class InstrumentationManager(
 
     private fun initializeTelemetryInspector() {
         if (options.debug) {
-            telemetryInspector = TelemetryInspector(inMemorySpanExporter, inMemoryLogExporter, inMemoryMetricExporter)
+            telemetryInspector = TelemetryInspector()
         }
     }
 
@@ -390,20 +391,28 @@ class InstrumentationManager(
             sdkKey: String,
             resource: Resource,
             logger: LDLogger,
+            telemetryInspector: TelemetryInspector?,
             options: Options,
         ): LogRecordProcessor {
             val primaryLogExporter = createOtlpLogExporter(options)
             sdkLoggerProviderBuilder.setResource(resource)
 
-            val finalExporter = createLogExporter(primaryLogExporter, exportSampler, logger, options)
+            val finalExporter = createLogExporter(
+                primaryLogExporter,
+                exportSampler,
+                logger,
+                telemetryInspector,
+                options
+            )
             val baseProcessor = createBatchLogRecordProcessor(finalExporter)
 
             // Here we set up a routing log processor that will route logs with a matching scope name to the
             // respective instrumentation's log record processor.  If the log's scope name does not match
             // an instrumentation's scope name, it will fall through to the base processor.  This was
             // originally added to route replay instrumentation logs through a separate log processing
             // pipeline to provide instrumentation specific caching and export.
-            val routingLogRecordProcessor = RoutingLogRecordProcessor(fallthroughProcessor = baseProcessor)
+            val routingLogRecordProcessor =
+                RoutingLogRecordProcessor(fallthroughProcessor = baseProcessor)
             for (i in options.instrumentations) {
                 i.getLogRecordProcessor(credential = sdkKey)?.let {
                     i.getLoggerScopeName().let { scopeName ->
@@ -422,13 +431,19 @@ class InstrumentationManager(
                 .build()
         }
 
-        private fun createLogExporter(primaryExporter: LogRecordExporter, exportSampler: ExportSampler, logger: LDLogger, options: Options): LogRecordExporter {
+        private fun createLogExporter(
+            primaryExporter: LogRecordExporter,
+            exportSampler: ExportSampler,
+            logger: LDLogger,
+            telemetryInspector: TelemetryInspector?,
+            options: Options
+        ): LogRecordExporter {
             val baseExporter = if (options.debug) {
                 LogRecordExporter.composite(
                     buildList {
                         add(primaryExporter)
                         add(DebugLogExporter(logger))
-//                        add(InMemoryLogRecordExporter.create().also { inMemoryLogExporter = it }) // TODO: figure out how to factor this out so functions can be static
+                        telemetryInspector?.let { add(it.logExporter) }
                     }
                 )
             } else {

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

@@ -12,7 +12,8 @@ import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter
  * @param metricExporter The in-memory metric exporter to read from
  */
 class TelemetryInspector(
-    val spanExporter: InMemorySpanExporter?,
-    val logExporter: InMemoryLogRecordExporter?,
-    val metricExporter: InMemoryMetricExporter?
-)
+) {
+    val spanExporter: InMemorySpanExporter by lazy { InMemorySpanExporter.create() }
+    val logExporter:InMemoryLogRecordExporter by lazy { InMemoryLogRecordExporter.create() }
+    val metricExporter: InMemoryMetricExporter by lazy { InMemoryMetricExporter.create() }
+}

sdk/@launchdarkly/observability-android/lib/src/test/kotlin/com/launchdarkly/observability/client/InstrumentationManagerTest.kt

@@ -63,6 +63,7 @@ class InstrumentationManagerTest {
             testSdkKey,
             testResource,
             mockLogger,
+            null,
             testOptions
         )
 
@@ -97,6 +98,7 @@ class InstrumentationManagerTest {
             testSdkKey,
             testResource,
             mockLogger,
+            null,
             testOptions
         )
 
@@ -124,6 +126,7 @@ class InstrumentationManagerTest {
             testSdkKey,
             testResource,
             mockLogger,
+            null,
             testOptions
         )