feat: MAUI integration hooks and refactor for 0.4.1 nuget

e2e/android/app/src/compose/java/com/example/androidobservability/MainActivity.kt

@@ -115,11 +115,7 @@ private fun MainScreen(viewModel: ViewModel, innerPadding: PaddingValues) {
             .verticalScroll(rememberScrollState())
             .padding(16.dp)
     ) {
-        Text(
-            text = "Masking",
-            style = MaterialTheme.typography.headlineSmall.copy(fontWeight = FontWeight.Bold),
-            modifier = Modifier.padding(bottom = 8.dp)
-        )
+        SessionReplayHeader()
         HorizontalDivider(modifier = Modifier.padding(bottom = 16.dp))
 
         MaskingButtons()
@@ -131,8 +127,6 @@ private fun MainScreen(viewModel: ViewModel, innerPadding: PaddingValues) {
         )
         HorizontalDivider(modifier = Modifier.padding(bottom = 16.dp))
 
-        SessionReplayToggle()
-
         IdentifyButtons(viewModel = viewModel)
 
         InstrumentationButtons(viewModel = viewModel)
@@ -146,19 +140,19 @@ private fun MainScreen(viewModel: ViewModel, innerPadding: PaddingValues) {
 }
 
 @Composable
-private fun SessionReplayToggle() {
+private fun SessionReplayHeader() {
     var isSessionReplayEnabled by rememberSaveable { mutableStateOf(true) }
 
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(bottom = 16.dp),
+            .padding(bottom = 8.dp),
         horizontalArrangement = Arrangement.SpaceBetween,
         verticalAlignment = Alignment.CenterVertically
     ) {
         Text(
             text = "Session Replay",
-            style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold)
+            style = MaterialTheme.typography.headlineSmall.copy(fontWeight = FontWeight.Bold)
         )
         Switch(
             checked = isSessionReplayEnabled,
@@ -295,7 +289,7 @@ private fun MaskingButtons() {
     )
 
     MaskingRow(
-        name = "Check",
+        name = "Dialogs",
         ctx = context,
         activity1 = XMLMaskingActivity::class.java,
         activity2 = ComposeMaskingActivity::class.java

e2e/android/app/src/compose/java/com/example/androidobservability/benchmark/BenchmarkExecutor.kt

@@ -96,7 +96,7 @@ class BenchmarkExecutor {
         }
 
         val exportDiffManager = ExportDiffManager(compression = method, scale = 1f)
-        val eventGenerator = RRWebEventGenerator(canvasDrawEntourage = 300)
+        val eventGenerator = RRWebEventGenerator(canvasDrawEntourage = 300, title = "benchmark")
         val json = Json
         var bytes = 0
         var isFirst = true

e2e/android/app/src/main/java/com/example/androidobservability/BaseApplication.kt

@@ -88,7 +88,13 @@ open class BaseApplication : Application() {
             .anonymous(true)
             .build()
 
-        LDClient.init(this@BaseApplication, ldConfig, context)
+        LDClient.init(this@BaseApplication, ldConfig, context, 1)
+        val anonContext = LDContext.builder(ContextKind.DEFAULT, "anonymous-userkey")
+            .anonymous(true)
+            .build()
+
+        //LDClient.get().identify(anonContext)
+
         telemetryInspector = observabilityPlugin.getTelemetryInspector()
 
         if (testUrl == null) {

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

@@ -4,7 +4,6 @@ import android.app.Application
 import com.launchdarkly.logging.LDLogger
 import com.launchdarkly.observability.api.ObservabilityOptions
 import com.launchdarkly.observability.coroutines.DispatcherProviderHolder
-import com.launchdarkly.observability.interfaces.LDExtendedInstrumentation
 import com.launchdarkly.observability.interfaces.Metric
 import com.launchdarkly.observability.network.GraphQLClient
 import com.launchdarkly.observability.network.SamplingApiService
@@ -16,7 +15,10 @@ import com.launchdarkly.observability.sampling.SamplingTraceExporter
 import io.opentelemetry.android.OpenTelemetryRum
 import io.opentelemetry.android.OpenTelemetryRumBuilder
 import io.opentelemetry.android.config.OtelRumConfig
+import io.opentelemetry.android.instrumentation.AndroidInstrumentation
+import io.opentelemetry.android.instrumentation.InstallationContext
 import io.opentelemetry.android.session.SessionConfig
+import io.opentelemetry.android.session.SessionManager
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.logs.Logger
 import io.opentelemetry.api.logs.Severity
@@ -64,17 +66,17 @@ import java.util.concurrent.TimeUnit
  * @param resources The OpenTelemetry resource describing this service.
  * @param logger The logger for internal logging.
  * @param observabilityOptions Additional configuration options for the SDK.
- * @param instrumentations A list of custom instrumentations to be added.
  */
 class InstrumentationManager(
     private val application: Application,
     private val sdkKey: String,
     private val resources: Resource,
     private val logger: LDLogger,
     private val observabilityOptions: ObservabilityOptions,
-    private val instrumentations: List<LDExtendedInstrumentation>,
 ) {
     private val otelRUM: OpenTelemetryRum
+    lateinit var sessionManager: SessionManager
+        private set
     private var otelMeter: Meter
     private var otelLogger: Logger
     private var otelTracer: Tracer
@@ -100,6 +102,8 @@ class InstrumentationManager(
         initializeTelemetryInspector()
         val otelRumConfig = createOtelRumConfig()
 
+        var capturedSessionManager: SessionManager? = null
+
         val rumBuilder = OpenTelemetryRum.builder(application, otelRumConfig)
             .addLoggerProviderCustomizer { sdkLoggerProviderBuilder, _ ->
                 val processor = createLoggerProcessor(
@@ -110,7 +114,6 @@ class InstrumentationManager(
                     logger,
                     telemetryInspector,
                     observabilityOptions,
-                    instrumentations
                 )
                 logProcessor = processor
                 return@addLoggerProviderCustomizer sdkLoggerProviderBuilder.addLogRecordProcessor(processor)
@@ -122,15 +125,19 @@ class InstrumentationManager(
                 return@addMeterProviderCustomizer configureMeterProvider(sdkMeterProviderBuilder)
             }
 
-        for (instrumentation in instrumentations) {
-            rumBuilder.addInstrumentation(instrumentation)
-        }
+        rumBuilder.addInstrumentation(object : AndroidInstrumentation {
+            override val name = "ld-session-manager-bridge"
+            override fun install(ctx: InstallationContext) {
+                capturedSessionManager = ctx.sessionManager
+            }
+        })
 
         if (observabilityOptions.instrumentations.launchTime) {
             addLaunchTimeInstrumentation(rumBuilder)
         }
 
         otelRUM = rumBuilder.build()
+        sessionManager = capturedSessionManager!!
         loadSamplingConfigAsync()
 
         otelMeter = otelRUM.openTelemetry.meterProvider.get(INSTRUMENTATION_SCOPE_NAME)
@@ -422,7 +429,6 @@ class InstrumentationManager(
             logger: LDLogger,
             telemetryInspector: TelemetryInspector?,
             observabilityOptions: ObservabilityOptions,
-            instrumentations: List<LDExtendedInstrumentation>,
         ): LogRecordProcessor {
             val primaryLogExporter = createOtlpLogExporter(observabilityOptions)
             sdkLoggerProviderBuilder.setResource(resource)
@@ -434,28 +440,10 @@ class InstrumentationManager(
                 observabilityOptions = observabilityOptions
             )
 
-            val samplingProcessor = SamplingLogProcessor(
+            return SamplingLogProcessor(
                 delegate = createBatchLogRecordProcessor(finalExporter),
                 sampler = exportSampler
             )
-
-            /*
-                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 = samplingProcessor)
-            instrumentations.forEach { instrumentation ->
-                instrumentation.getLogRecordProcessor(credential = sdkKey)?.let { processor ->
-                    instrumentation.getLoggerScopeName().let { scopeName ->
-                        routingLogRecordProcessor.addProcessor(scopeName, processor)
-                    }
-                }
-            }
-
-            return routingLogRecordProcessor
         }
 
         private fun createOtlpLogExporter(observabilityOptions: ObservabilityOptions): LogRecordExporter {

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

@@ -3,7 +3,6 @@ package com.launchdarkly.observability.client
 import android.app.Application
 import com.launchdarkly.logging.LDLogger
 import com.launchdarkly.observability.api.ObservabilityOptions
-import com.launchdarkly.observability.interfaces.LDExtendedInstrumentation
 import com.launchdarkly.observability.interfaces.Metric
 import com.launchdarkly.observability.interfaces.Observe
 import io.opentelemetry.api.common.Attributes
@@ -30,21 +29,21 @@ class ObservabilityClient : Observe {
      * @param resource The resource.
      * @param logger The logger.
      * @param options Additional options for the client.
-     * @param instrumentations A list of extended instrumentation providers.
      */
     constructor(
         application: Application,
         sdkKey: String,
         resource: Resource,
         logger: LDLogger,
         options: ObservabilityOptions,
-        instrumentations: List<LDExtendedInstrumentation>
     ) {
         this.instrumentationManager = InstrumentationManager(
-            application, sdkKey, resource, logger, options, instrumentations
+            application, sdkKey, resource, logger, options,
         )
     }
 
+    val sessionManager get() = instrumentationManager.sessionManager
+
     internal constructor(
         instrumentationManager: InstrumentationManager
     ) {

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

@@ -3,6 +3,7 @@ package com.launchdarkly.observability.client
 import android.app.Application
 import com.launchdarkly.logging.LDLogger
 import com.launchdarkly.observability.api.ObservabilityOptions
+import io.opentelemetry.android.session.SessionManager
 
 /**
  * Shared information between plugins.
@@ -12,4 +13,5 @@ data class ObservabilityContext(
     val options: ObservabilityOptions,
     val application: Application,
     val logger: LDLogger,
+    var sessionManager: SessionManager? = null,
 )

sdk/@launchdarkly/observability-android/lib/src/main/kotlin/com/launchdarkly/observability/plugin/Observability.kt

@@ -121,13 +121,12 @@ class Observability(
                     }
                 }
 
-                val instrumentations = InstrumentationContributorManager.get(lDClient).flatMap { it.provideInstrumentations() }
-                observabilityClient = ObservabilityClient(
-                    application, sdkKey, resourceBuilder.build(), logger, options, instrumentations
+                val client = ObservabilityClient(
+                    application, sdkKey, resourceBuilder.build(), logger, options,
                 )
-                observabilityClient?.let {
-                    LDObserve.init(it)
-                }
+                observabilityClient = client
+                LDObserve.context?.sessionManager = client.sessionManager
+                LDObserve.init(client)
             } else {
                 logger.warn("Observability could not be initialized for sdkKey: $sdkKey")
             }