feat: 50% decrease Nuget Android part in MAUI

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

@@ -9,16 +9,17 @@ import com.launchdarkly.observability.replay.PrivacyProfile
 import com.launchdarkly.observability.replay.ReplayOptions
 import com.launchdarkly.observability.replay.plugin.SessionReplay
 import com.launchdarkly.observability.replay.view
+import com.launchdarkly.observability.context.LDObserveContext
+import com.launchdarkly.observability.sdk.LDObserve
+import com.launchdarkly.observability.sdk.LDReplay
 import com.launchdarkly.sdk.ContextKind
 import com.launchdarkly.sdk.LDContext
 import com.launchdarkly.sdk.android.Components
-import com.launchdarkly.sdk.android.LDAndroidLogging
+import com.launchdarkly.sdk.android.FeatureFlagChangeListener
 import com.launchdarkly.sdk.android.LDClient
 import com.launchdarkly.sdk.android.LDConfig
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
-import com.launchdarkly.observability.sdk.LDReplay
-import com.launchdarkly.sdk.android.FeatureFlagChangeListener
 
 open class BaseApplication : Application() {
 
@@ -38,32 +39,32 @@ open class BaseApplication : Application() {
         instrumentations = ObservabilityOptions.Instrumentations(
             crashReporting = true, launchTime = true, activityLifecycle = true
         ),
-        logAdapter = LDAndroidLogging.adapter(),
+    )
+
+    val sessionReplayPlugin = SessionReplay(
+        options = ReplayOptions(
+            enabled = false,
+            privacyProfile = PrivacyProfile(
+                maskText = false,
+                maskWebViews = true,
+                maskViews = listOf(
+                    view(ImageView::class.java),
+                ),
+                maskXMLViewIds = listOf("smoothieTitle")
+            )
+        )
     )
 
     var testUrl: String? = null
 
+    // example on creating OBS/SR with flagging sdk
     open fun realInit() {
         val observabilityPlugin = Observability(
             application = this@BaseApplication,
             mobileKey = LAUNCHDARKLY_MOBILE_KEY,
             options = testUrl?.let { observabilityOptions.copy(backendUrl = it, otlpEndpoint = it) } ?: observabilityOptions
         )
 
-        val sessionReplayPlugin = SessionReplay(
-            options = ReplayOptions(
-                enabled = false,
-                privacyProfile = PrivacyProfile(
-                    maskText = false,
-                    maskWebViews = true,
-                    maskViews = listOf(
-                        view(ImageView::class.java),
-                    ),
-                    maskXMLViewIds = listOf("smoothieTitle")
-                )
-            )
-        )
-
         // Set LAUNCHDARKLY_MOBILE_KEY to your LaunchDarkly mobile key found on the LaunchDarkly
         // dashboard in the start guide.
         // If you want to disable the Auto EnvironmentAttributes functionality.
@@ -96,6 +97,37 @@ open class BaseApplication : Application() {
         LDReplay.start()
     }
 
+    // example on creating OBS/SR without flagging
+    open fun realIndependentInit() {
+        val effectiveOptions = testUrl?.let {
+            observabilityOptions.copy(backendUrl = it, otlpEndpoint = it)
+        } ?: observabilityOptions
+
+        val context = LDObserveContext.builder(LDObserveContext.DEFAULT_KIND, "example-user-key")
+            .anonymous(true)
+            .build()
+
+        LDObserve.init(
+            application = this@BaseApplication,
+            mobileKey = LAUNCHDARKLY_MOBILE_KEY,
+            ldContext = context,
+            options = effectiveOptions,
+            replayOptions = ReplayOptions(
+                enabled = false,
+                privacyProfile = PrivacyProfile(
+                    maskText = false,
+                    maskWebViews = true,
+                    maskViews = listOf(
+                        view(ImageView::class.java),
+                    ),
+                    maskXMLViewIds = listOf("smoothieTitle")
+                )
+            )
+        )
+
+        LDReplay.start()
+    }
+
     fun flagEvaluation() {
         val flagKey = "feature1"
         val value = LDClient.get().boolVariation(flagKey, false)

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

@@ -14,6 +14,7 @@ import junit.framework.TestCase.assertEquals
 import junit.framework.TestCase.assertFalse
 import junit.framework.TestCase.assertNotNull
 import junit.framework.TestCase.assertTrue
+import org.junit.After
 import org.junit.Ignore
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -27,6 +28,11 @@ class DisablingConfigOptionsE2ETest {
 
     private val application = ApplicationProvider.getApplicationContext<Application>() as TestApplication
 
+    @After
+    fun tearDown() {
+        application.tearDownTest()
+    }
+
     @Test
     fun `Logs should NOT be exported when logsApiLevel is NONE`() {
         application.observabilityOptions = getOptionsAllEnabled().copy(logsApiLevel = ObservabilityOptions.LogLevel.NONE)
@@ -46,15 +52,16 @@ class DisablingConfigOptionsE2ETest {
     fun `Logs should NOT be exported when log severity is lower than logsApiLevel`() {
         application.observabilityOptions = getOptionsAllEnabled().copy(logsApiLevel = ObservabilityOptions.LogLevel.INFO)
         application.initForTest()
-        val logsUrl = "http://localhost:${application.mockWebServer?.port}/v1/logs"
 
         triggerTestLog(severity = Severity.TRACE)
         LDObserve.flush()
+        // With logsApiLevel = INFO the SDK still emits its own INFO "LD.identify" log during init,
+        // so we can't assert on "no logs at all" or "no /v1/logs request". The intent is that the
+        // TRACE test-log specifically is filtered out.
         waitForTelemetryData(telemetryInspector = application.telemetryInspector, telemetryType = TelemetryType.LOGS)
         val logsExported = application.telemetryInspector?.logExporter?.finishedLogRecordItems
 
-        assertTrue(logsExported?.isEmpty() == true)
-        assertFalse(requestsContainsUrl(logsUrl))
+        assertFalse(logsExported.orEmpty().any { it.bodyValue?.value.toString() == TEST_LOG_MESSAGE })
     }
 
     @Test
@@ -195,15 +202,18 @@ class DisablingConfigOptionsE2ETest {
             instrumentations = ObservabilityOptions.Instrumentations(crashReporting = false)
         )
         application.initForTest()
-        val logsUrl = "http://localhost:${application.mockWebServer?.port}/v1/logs"
 
         Thread { throw RuntimeException("Exception for testing") }.start()
 
         waitForTelemetryData(telemetryInspector = application.telemetryInspector, telemetryType = TelemetryType.LOGS)
         val logsExported = application.telemetryInspector?.logExporter?.finishedLogRecordItems
 
-        assertFalse(requestsContainsUrl(logsUrl))
-        assertEquals(0, logsExported?.size)
+        // logsApiLevel is independent of crash reporting: unrelated SDK logs (e.g. LD.identify)
+        // may still be exported. We only assert that no crash log reached the exporter.
+        val crashLogs = logsExported.orEmpty().filter {
+            it.instrumentationScopeInfo.name == CRASH_INSTRUMENTATION_SCOPE
+        }
+        assertEquals(0, crashLogs.size)
     }
 
     @Test
@@ -238,7 +248,7 @@ class DisablingConfigOptionsE2ETest {
 
     private fun triggerTestLog(severity: Severity = Severity.INFO) {
         LDObserve.recordLog(
-            message = "test-log",
+            message = TEST_LOG_MESSAGE,
             severity = severity
         )
     }
@@ -275,4 +285,9 @@ class DisablingConfigOptionsE2ETest {
             )
         )
     }
+
+    companion object {
+        private const val TEST_LOG_MESSAGE = "test-log"
+        private const val CRASH_INSTRUMENTATION_SCOPE = "io.opentelemetry.crash"
+    }
 }

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

@@ -12,6 +12,7 @@ import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.logs.Severity
 import junit.framework.TestCase.assertEquals
 import kotlinx.coroutines.test.runTest
+import org.junit.After
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -55,15 +56,24 @@ class SamplingE2ETest {
         telemetryInspector = application.telemetryInspector
     }
 
+    @After
+    fun tearDown() {
+        application.tearDownTest()
+    }
+
     @Test
     fun `should avoid exporting logs matching sampling configuration for logs`() = runTest {
         triggerLogs()
-        telemetryInspector?.logExporter?.flush()
+        // Force the BatchLogRecordProcessor to drain everything to the exporter so the
+        // assertion doesn't race with the batch scheduler.
+        LDObserve.flush()
         waitForTelemetryData(telemetryInspector = application.telemetryInspector, telemetryType = TelemetryType.LOGS)
 
-        val logsExported = telemetryInspector?.logExporter?.finishedLogRecordItems?.map {
-            it.bodyValue?.value.toString()
-        }
+        val logsExported = telemetryInspector?.logExporter?.finishedLogRecordItems
+            ?.map { it.bodyValue?.value.toString() }
+            // The SDK emits an unrelated "LD.identify" INFO log during init; filter it out so
+            // this test only observes the logs triggered by triggerLogs().
+            ?.filter { it != LD_IDENTIFY_LOG_BODY }
 
         // Only first and final logs should be exported
         assertEquals(2, logsExported?.size)
@@ -74,7 +84,7 @@ class SamplingE2ETest {
     @Test
     fun `should avoid exporting spans matching sampling configuration for spans`() = runTest {
         triggerSpans()
-        telemetryInspector?.spanExporter?.flush()
+        LDObserve.flush()
         waitForTelemetryData(telemetryInspector = application.telemetryInspector, telemetryType = TelemetryType.SPANS)
 
         val spansExported = telemetryInspector?.spanExporter?.finishedSpanItems?.map {
@@ -219,4 +229,8 @@ class SamplingE2ETest {
             )
         )
     }
+
+    companion object {
+        private const val LD_IDENTIFY_LOG_BODY = "LD.identify"
+    }
 }

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

@@ -49,13 +49,33 @@ class TestApplication : BaseApplication() {
         super.realInit()
     }
 
-    override fun onTerminate() {
+    /**
+     * Tears down per-test state so tests don't leak into each other.
+     *
+     * Robolectric isolates Android framework classes with a per-method sandbox classloader,
+     * but third-party JVM classes (including `com.launchdarkly.sdk.android.LDClient`) live
+     * in the shared system classloader. `LDClient.init()` silently returns the existing
+     * client if already initialized, which means a second test's `Observability` plugin is
+     * never registered and `LDObserve` keeps pointing at the previous test's
+     * `ObservabilityService` (with a now-dead mock server port). Closing `LDClient` resets
+     * its `instances` static so the next `init` fully reinitializes.
+     */
+    fun tearDownTest() {
+        try {
+            LDClient.get().close()
+        } catch (_: Throwable) {
+            // LDClient may not have been initialized successfully; ignore.
+        }
         mockWebServer?.let {
             it.shutdown()
             mockWebServer = null
         }
-        LDClient.get().close()
+        telemetryInspector = null
         SignalFromDiskExporter.resetForTesting()
+    }
+
+    override fun onTerminate() {
+        tearDownTest()
         super.onTerminate()
     }
 }

sdk/@launchdarkly/mobile-dotnet/android/native/LDObserve/build.gradle.kts

@@ -40,11 +40,6 @@ dependencies {
     implementation("androidx.core:core-ktx:1.15.0")
     "copyDependencies"("androidx.core:core-ktx:1.15.0")
 
-    // Copy dependencies for binding library
-    // Uncomment line below and replace dependency.name.goes.here with your dependency
-    implementation("com.launchdarkly:launchdarkly-android-client-sdk:5.11.0")
-    "copyDependencies"("com.launchdarkly:launchdarkly-android-client-sdk:5.11.0")
-
     // Intentionally use a non-existent version so this dependency MUST be
     // satisfied by composite-build substitution (settings.gradle.kts).
     // If substitution breaks, the build should fail instead of silently