feat: MAUI Network tracing 0.8.0 (#463)

## Summary

- **Network request tracing for .NET MAUI**: Adds `System.Net.Http`
Activity source to `LDTracer` so HTTP requests made from .NET are
automatically captured as spans. On iOS, native `urlSession`
instrumentation is disabled since tracing now happens on the .NET side.
On Android, `UseNativeHttpHandler` is set to `false` in the sample
project so `SocketsHttpHandler` emits Activity diagnostics.
- **Configurable instrumentation options**: Introduces
`InstrumentationOptions` (with `NetworkRequests` and `LaunchTimes`
toggles) on `ObservabilityOptions`, plumbed through the iOS (Swift) and
Android (Kotlin) native bridges so each instrumentation can be
individually enabled/disabled from the .NET layer.
- **Span-context-aware logging**: `LDObserve.RecordLog` now accepts an
optional `SpanContext?` parameter. When provided, its trace/span IDs are
forwarded to the native logger; otherwise the ambient `Activity.Current`
is used. The native logger is obtained via new `ObjcLogger` (iOS) and
`RealLogger` (Android) bridge classes, replacing the old `recordLog`
method on `ObservabilityBridge`.
- **New public APIs on `LDObserve`**: `RecordError(Exception)`,
`StartRootSpan(string)`, and `GetTracer()` (with no-op fallback before
init).
- **Android SDK**: `TracesApi.startSpan` now defaults `attributes` to
`Attributes.empty()`.
- **E2E example**: Android `ViewModel` demonstrates parent/child span
creation and cross-thread context propagation.
- **Version bump**: `LaunchDarkly.SessionReplay` 0.6.0 → 0.8.0.

<img width="1592" height="1740" alt="image"
src="https://github.com/user-attachments/assets/7f95d3e1-db90-4607-bf8d-48f0706b5716"
/>

## Changes by area

### .NET SDK (`mobile-dotnet/observability`)

- New `InstrumentationOptions` class with `NetworkRequests` and
`LaunchTimes` booleans (default `true`), added to
`ObservabilityOptions`.
- `ObservabilityPlugin` enables
`System.Net.Http.EnableActivityPropagation` when network request tracing
is on.
- `LDTracer` is no longer a singleton; accepts `serviceName` and
`networkRequests` params; conditionally subscribes to `System.Net.Http`
Activity source.
- New `ObservabilityService` consolidates all bridge calls, tracer
lifecycle, and native logger acquisition. Replaces deleted
`NativeObserve`.
- `LDObserve` is now a thin static facade over `ObservabilityService`;
safe to call before initialization (no-ops).
- `PluginOrchestrator` renamed properties to `ObservabilityService` /
`SessionReplayService`; calls `LDObserve.Initialize()` after native
start.
- Native bridge mappings (`LDNative.Android.cs`, `SRClient.iOS.cs`) pass
new instrumentation options through.

### Native bridges — iOS (Swift)

- `ObjcObservabilityOptions` adds `networkRequests` and `launchTimes`
properties.
- `ObservabilityBridge` disables `urlSession` instrumentation and makes
`launchTimes` configurable.
- New `ObjcLogger` class exposed via `LDObserveBridge.getObjcLogger()`.
- iOS binding `ApiDefinition.cs` updated with new properties and
`ObjcLogger` interface.

### Native bridges — Android (Kotlin)

- `LDObservabilityOptions` adds `launchTime` field; options classes
moved to `OptionsBridge.kt`.
- `ObservabilityBridge` reads `launchTime` from options instead of
hardcoding `true`; `recordLog` removed.
- New `RealLogger` wrapper around `KotlinLogger` for C# binding.
- `LDObserveBridgeAdapter` exposes `getLogger()`.

### Android SDK (`observability-android`)

- `TracesApi.startSpan` parameter `attributes` now defaults to
`Attributes.empty()`.

### E2E / Sample

- Android e2e `ViewModel` demonstrates parent-child span creation and
cross-thread context propagation.
- MAUI sample `MauiProgram.cs` uses the new `InstrumentationOptions`
API.
- MAUI sample `.csproj` sets `UseNativeHttpHandler=false` for Android to
enable `System.Net.Http` Activity diagnostics.


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Touches cross-platform observability initialization and tracing
sources (including automatic `System.Net.Http` span capture), so
misconfiguration could change telemetry volume/correlation or miss spans
on iOS/Android.
> 
> **Overview**
> Adds **automatic .NET MAUI HTTP request tracing** by extending
`LDTracer` to optionally subscribe to the `System.Net.Http` Activity
source and enabling `System.Net.Http.EnableActivityPropagation` when
configured.
> 
> Introduces `InstrumentationOptions` on `ObservabilityOptions` (toggles
for `NetworkRequests` and `LaunchTimes`) and plumbs these through the
Android (Kotlin) and iOS (Swift + binding) native bridges; iOS disables
native `urlSession` tracing in favor of .NET-side tracing, and Android
bridge now respects a configurable `launchTime` flag.
> 
> Hardens initialization by making `PluginOrchestrator` initialize only
once, updates samples/e2e to demonstrate cross-thread span context
propagation and config usage (including Android
`UseNativeHttpHandler=false`), and bumps `LaunchDarkly.SessionReplay`
package version to `0.8.0`.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
abda519. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: abelonogov-ld

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

@@ -14,6 +14,8 @@ import com.launchdarkly.sdk.android.LDClient
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.logs.Severity
+import io.opentelemetry.api.trace.Span
+import io.opentelemetry.context.Context
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import okhttp3.OkHttpClient
@@ -22,6 +24,7 @@ import java.io.BufferedInputStream
 import java.net.HttpURLConnection
 import java.net.URL
 
+
 class ViewModel(application: Application) : AndroidViewModel(application) {
 
     fun triggerMetric() {
@@ -83,6 +86,23 @@ class ViewModel(application: Application) : AndroidViewModel(application) {
 
     fun triggerLogWithContext(message: String) {
         val text = message.ifEmpty { "Log with span context" }
+
+        val parentSpan = LDObserve.startSpan("parentSpan")
+        parentSpan.makeCurrent().use {
+            val context = Context.current()
+
+            Thread {
+                context.makeCurrent().use {
+                    val childSpan = LDObserve.startSpan("childSpan")
+                    childSpan.makeCurrent().use {
+                        // do work
+                        childSpan.end()
+                    }
+                }
+            }.start()
+        }
+        parentSpan.end()
+
         viewModelScope.launch(Dispatchers.IO) {
             val span = LDObserve.startSpan(
                 name = "log-context-demo",
@@ -97,6 +117,10 @@ class ViewModel(application: Application) : AndroidViewModel(application) {
             // Simulate a detached thread where OTel context is lost automatically.
             // Span.current() here returns INVALID, so we pass the captured context explicitly.
             Thread {
+                Span.wrap(capturedContext).makeCurrent().use {
+                    val childSpan = LDObserve.startSpan("child of log-context-demo", Attributes.empty())
+                    childSpan.end()
+                }
                 LDObserve.recordLog(
                     message = text,
                     severity = Severity.WARN,

sdk/@launchdarkly/mobile-dotnet/android/native/LDObserve/src/main/java/com/example/LDObserve/ObservabilityBridge.kt

@@ -84,7 +84,7 @@ public class ObservabilityBridge(
                 tracesApi = com.launchdarkly.observability.api.ObservabilityOptions.TracesApi(includeErrors = true, includeSpans = true),
                 metricsApi = com.launchdarkly.observability.api.ObservabilityOptions.MetricsApi.enabled(),
                 instrumentations = com.launchdarkly.observability.api.ObservabilityOptions.Instrumentations(
-                    crashReporting = false, launchTime = true, activityLifecycle = true
+                    crashReporting = false, launchTime = observability.launchTime, activityLifecycle = true
                 ),
                 logAdapter = LDAndroidLogging.adapter(),
             )

sdk/@launchdarkly/mobile-dotnet/android/native/LDObserve/src/main/java/com/example/LDObserve/OptionsBridge.kt

@@ -8,6 +8,7 @@ public class LDObservabilityOptions {
     @JvmField var backendUrl: String = ""
     @JvmField var contextFriendlyName: String? = null
     @JvmField var attributes: HashMap<String, Any?>? = null
+    @JvmField var launchTime: Boolean = true
 
     constructor()
 
@@ -18,7 +19,8 @@ public class LDObservabilityOptions {
         otlpEndpoint: String,
         backendUrl: String,
         contextFriendlyName: String?,
-        attributes: HashMap<String, Any?>? = null
+        attributes: HashMap<String, Any?>? = null,
+        launchTime: Boolean = true
     ) {
         this.isEnabled = isEnabled
         this.serviceName = serviceName
@@ -27,6 +29,7 @@ public class LDObservabilityOptions {
         this.backendUrl = backendUrl
         this.contextFriendlyName = contextFriendlyName
         this.attributes = attributes
+        this.launchTime = launchTime
     }
 }
 

sdk/@launchdarkly/mobile-dotnet/macios/LDObserve.MaciOS.Binding/ApiDefinition.cs

@@ -30,6 +30,12 @@ interface ObjcObservabilityOptions
 
         [NullAllowed, Export("attributes")]
         NSDictionary Attributes { get; set; }
+
+        [Export("networkRequests")]
+        bool NetworkRequests { get; set; }
+
+        [Export("launchTimes")]
+        bool LaunchTimes { get; set; }
     }
 
     [BaseType(typeof(NSObject))]

sdk/@launchdarkly/mobile-dotnet/macios/native/LDObserve/Sources/ObservabilityBridge.swift

@@ -49,12 +49,12 @@ public final class ObservabilityBridge: NSObject {
                 resourceAttributes: buildResourceAttributes(observability.attributes),
                 crashReporting: .init(source: .none),
                 instrumentation: .init(
-                    urlSession: .enabled,
+                    urlSession: .disabled, // Network tracing happens on the .NET side via System.Net.Http activities.
                     userTaps: .enabled,
                     memory: .disabled,
                     memoryWarnings: .disabled,
                     cpu: .disabled,
-                    launchTimes: .enabled
+                    launchTimes: observability.launchTimes ? .enabled : .disabled
                 )
             ))
             observabilityPlugin.distroAttributes = [

sdk/@launchdarkly/mobile-dotnet/macios/native/LDObserve/Sources/OptionsBridge.swift

@@ -7,6 +7,8 @@ public final class ObjcObservabilityOptions: NSObject {
     @objc public var otlpEndpoint: String = ""
     @objc public var backendUrl: String = ""
     @objc public var attributes: NSDictionary?
+    @objc public var networkRequests: Bool = true
+    @objc public var launchTimes: Bool = true
 
     @objc public override init() {
         super.init()

sdk/@launchdarkly/mobile-dotnet/observability/Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 	<PropertyGroup>
 		<PackageId>LaunchDarkly.SessionReplay</PackageId>
-		<Version>0.6.0</Version>
+		<Version>0.8.0</Version>
 		<UseLocalClientSdk>false</UseLocalClientSdk>
 		<Authors>LaunchDarkly</Authors>
 		<Owners>LaunchDarkly</Owners>

sdk/@launchdarkly/mobile-dotnet/observability/bridge/LDNative.Android.cs

@@ -14,7 +14,8 @@ internal static class LDNativeAndroidMapping
             options.OtlpEndpoint,
             options.BackendUrl,
             options.ContextFriendlyName,
-            DictionaryTypeConverters.ToJavaDictionary(options.Attributes)
+            DictionaryTypeConverters.ToJavaDictionary(options.Attributes),
+            options.Instrumentation.LaunchTimes
         );
     }
 

sdk/@launchdarkly/mobile-dotnet/observability/bridge/SRClient.iOS.cs

@@ -26,7 +26,9 @@ public void Start(string mobileKey, ObservabilityOptions observability, SessionR
             ServiceVersion = observability.ServiceVersion ?? "0.1.0",
             OtlpEndpoint = observability.OtlpEndpoint ?? "https://otel.observability.app.launchdarkly.com:4318",
             BackendUrl = observability.BackendUrl ?? "https://pub.observability.app.launchdarkly.com",
-            Attributes = DictionaryTypeConverters.ToNSDictionary(observability.Attributes)
+            Attributes = DictionaryTypeConverters.ToNSDictionary(observability.Attributes),
+            NetworkRequests = observability.Instrumentation.NetworkRequests,
+            LaunchTimes = observability.Instrumentation.LaunchTimes
         };
 
         var objcReplay = new ObjcSessionReplayOptions

sdk/@launchdarkly/mobile-dotnet/observability/infra/PluginOrchestrator.cs

@@ -16,6 +16,7 @@ internal sealed class PluginOrchestrator
 
         private int _createdCount;
         private int _registeredCount;
+        private bool _initialized;
 
         internal ObservabilityService? ObservabilityService { get; private set; }
         internal SessionReplayService? SessionReplayService { get; private set; }
@@ -24,7 +25,8 @@ private PluginOrchestrator() { }
 
         private void InitializeAll()
         {
-            if (_registeredCount < _createdCount) return;
+            if (_initialized || _registeredCount < _createdCount) return;
+            _initialized = true;
 
             var metadata = ObservabilityService?.Metadata ?? SessionReplayService?.Metadata;
             if (metadata == null) return;