@barrysolomon/mobile-react-native 0.1.0-alpha → 0.2.0-alpha

package/android/src/main/java/com/dash0/mobile/reactnative/Dash0MobileModule.kt

@@ -48,6 +48,9 @@ class Dash0MobileModule internal constructor(
                         .getArrayOrNull("nativeAutoCapture")
                         ?.toStringList()
                         ?: emptyList(),
+                    sampling = config
+                        .getMapOrNull("sampling")
+                        ?.toSamplingConfig(),
                 ),
             )
             promise.resolve(null)
@@ -58,15 +61,20 @@ class Dash0MobileModule internal constructor(
 
     @ReactMethod
     fun emitBatch(payloads: ReadableArray, promise: Promise) {
-        try {
-            for (i in 0 until payloads.size()) {
+        // Isolate each payload: a single malformed entry (e.g. wrong-typed
+        // severity/value) must not reject the whole batch, or JS retries the
+        // entire batch forever and never makes progress. Drop the bad one,
+        // keep going.
+        for (i in 0 until payloads.size()) {
+            try {
                 val p = payloads.getMap(i) ?: continue
                 dispatch(p)
+            } catch (t: Throwable) {
+                // Best-effort: skip the offending payload and continue.
+                continue
             }
-            promise.resolve(null)
-        } catch (t: Throwable) {
-            promise.reject("Dash0Mobile.emitBatch", t)
         }
+        promise.resolve(null)
     }
 
     @ReactMethod
@@ -94,7 +102,7 @@ class Dash0MobileModule internal constructor(
         val attrs = p.getMapOrNull("attributes")?.toAttributeMap() ?: emptyMap()
         when (kind) {
             "log" -> {
-                val severity = p.getInt("severity")
+                val severity = p.getIntOrDefault("severity", 9)
                 sink.emitLog(
                     name = p.getString("name") ?: return,
                     severity = severity,
@@ -132,7 +140,7 @@ class Dash0MobileModule internal constructor(
             "metric" -> sink.recordMetric(
                 name = p.getString("name") ?: return,
                 instrumentType = p.getString("instrumentType") ?: "counter",
-                value = p.getDouble("value"),
+                value = p.getDoubleOrDefault("value", 0.0),
                 attributes = attrs,
                 timeUnixNano = p.getStringAsLong("timeUnixNano"),
             )
@@ -169,6 +177,16 @@ private fun ReadableArray.toStringList(): List<String> {
 private fun ReadableMap.getStringAsLong(key: String): Long =
     getStringOrNull(key)?.toLongOrNull() ?: 0L
 
+// Type-guarded numeric reads. ReadableMap.getInt/getDouble throw if the JS
+// value isn't actually a number (e.g. a stringified severity). Check the
+// declared type first and fall back to the default so one malformed payload
+// can't blow up dispatch.
+private fun ReadableMap.getIntOrDefault(key: String, default: Int): Int =
+    if (hasKey(key) && getType(key) == ReadableType.Number) getInt(key) else default
+
+private fun ReadableMap.getDoubleOrDefault(key: String, default: Double): Double =
+    if (hasKey(key) && getType(key) == ReadableType.Number) getDouble(key) else default
+
 private fun ReadableMap.toStringMap(): Map<String, String> {
     val iter = keySetIterator()
     val out = LinkedHashMap<String, String>()
@@ -181,6 +199,16 @@ private fun ReadableMap.toStringMap(): Map<String, String> {
     return out
 }
 
+private fun ReadableMap.getDoubleOrNull(key: String): Double? =
+    if (hasKey(key) && getType(key) == ReadableType.Number) getDouble(key) else null
+
+private fun ReadableMap.toSamplingConfig(): BridgeSamplingConfig =
+    BridgeSamplingConfig(
+        strategy = SamplingStrategy.fromToken(getStringOrNull("strategy")),
+        normalRate = getDoubleOrNull("normalRate"),
+        highPriorityRate = getDoubleOrNull("highPriorityRate"),
+    )
+
 private fun ReadableMap.toAttributeMap(): Map<String, Any?> {
     val iter = keySetIterator()
     val out = LinkedHashMap<String, Any?>()

package/android/src/main/java/com/dash0/mobile/reactnative/Dash0MobilePackage.kt

@@ -3,12 +3,81 @@ package com.dash0.mobile.reactnative
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.network.OkHttpClientFactory
+import com.facebook.react.modules.network.OkHttpClientProvider
 import com.facebook.react.uimanager.ViewManager
+import java.util.concurrent.atomic.AtomicBoolean
+import okhttp3.OkHttpClient
 
 class Dash0MobilePackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-        listOf(Dash0MobileModule(reactContext))
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        // Install the OkHttp interceptor BEFORE any JS runs. createNativeModules
+        // is invoked during ReactInstanceManager bring-up, ahead of the JS
+        // bundle executing — which is exactly the requirement: expo/fetch (Expo
+        // SDK 52+) builds its OkHttp client off OkHttpClientProvider the first
+        // time JS issues a request, so the factory must already be replaced by
+        // then.
+        //
+        // The interceptor itself is a pass-through no-op until the sink arms it
+        // on `Dash0Mobile.start`, so installing it this early is safe even if
+        // the app never calls start().
+        installOkHttpInterceptor()
+        return listOf(Dash0MobileModule(reactContext))
+    }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
         emptyList()
+
+    private fun installOkHttpInterceptor() {
+        // Idempotent: createNativeModules can run more than once (JS reload /
+        // multiple ReactInstanceManagers). Install exactly once per process; the
+        // interceptor instance is a process-wide singleton, so one install
+        // covers every later ReactInstanceManager.
+        if (!installed.compareAndSet(false, true)) return
+        try {
+            // Set a factory that builds RN's DEFAULT-configured client and adds
+            // our interceptor on top.
+            //
+            // We use createClientBuilder() rather than capturing+delegating to a
+            // "previous" factory because react-native exposes no stable
+            // getOkHttpClientFactory() — it is absent in react-android 0.76 (the
+            // declared peer), so capturing the previous factory does not compile
+            // against the supported RN version. createClientBuilder() returns
+            // RN's default builder (timeouts, cookie jar, default interceptors),
+            // so we preserve RN's standard client config and only add ours. This
+            // is the documented RN interceptor-injection pattern. A host that had
+            // installed its OWN custom factory is replaced with default+interceptor
+            // (the unavoidable trade without a getter).
+            OkHttpClientProvider.setOkHttpClientFactory(
+                InterceptorInstallingFactory(NetworkInstrumentation.interceptor),
+            )
+        } catch (_: Throwable) {
+            // Installing instrumentation must NEVER crash host bring-up. If the
+            // RN networking module isn't present or the API shape changed, we
+            // ship without native network capture rather than taking the app
+            // down. Telemetry is always subordinate to the host. Reset the guard
+            // so a later attempt can retry.
+            installed.set(false)
+        }
+    }
+
+    private companion object {
+        private val installed = AtomicBoolean(false)
+    }
+}
+
+/**
+ * Builds RN's default-configured OkHttp client (via [OkHttpClientProvider.createClientBuilder])
+ * and adds the Dash0 network interceptor as an *application* interceptor — so it
+ * sees the logical request (redirects collapsed into one call) and injects
+ * `traceparent` once per logical request.
+ */
+private class InterceptorInstallingFactory(
+    private val interceptor: OTelNetworkInterceptor,
+) : OkHttpClientFactory {
+    override fun createNewNetworkModuleClient(): OkHttpClient =
+        OkHttpClientProvider.createClientBuilder()
+            .addInterceptor(interceptor)
+            .build()
 }

package/android/src/main/java/com/dash0/mobile/reactnative/NetworkInstrumentation.kt

@@ -0,0 +1,28 @@
+/*
+ * NetworkInstrumentation — the single shared seam between the two halves of
+ * the Android network story that run at different times:
+ *
+ *   1. [Dash0MobilePackage.createNativeModules] (pre-JS): creates the
+ *      [OTelNetworkInterceptor] and registers it on React Native's shared
+ *      OkHttp client via OkHttpClientProvider. This MUST happen before any JS
+ *      runs so expo/fetch's OkHttp client picks it up.
+ *
+ *   2. [OTelMobileCallSink.start] (when JS calls `Dash0Mobile.start`): the
+ *      tracer only exists after OTelMobile has been started, so this is where
+ *      the interceptor is armed with the tracer + collector-host ignore list.
+ *
+ * A process-wide singleton bridges the two: the package installs it, the sink
+ * arms it. Splitting "install" from "arm" is what keeps the interceptor a safe
+ * pass-through no-op for the window between process launch and `start()`.
+ */
+package com.dash0.mobile.reactnative
+
+object NetworkInstrumentation {
+    /**
+     * The one interceptor instance registered on the OkHttp pipeline. Created
+     * lazily and held for the process lifetime — the OkHttp client factory
+     * captures this exact reference, and [OTelMobileCallSink] arms/disarms the
+     * same reference on start/shutdown.
+     */
+    val interceptor: OTelNetworkInterceptor by lazy { OTelNetworkInterceptor() }
+}

package/android/src/main/java/com/dash0/mobile/reactnative/OTelMobileCallSink.kt

@@ -10,6 +10,7 @@ package com.dash0.mobile.reactnative
 import android.content.Context
 import io.opentelemetry.android.mobile.OTelMobile
 import io.opentelemetry.android.mobile.config.MobileConfig
+import io.opentelemetry.android.mobile.sampling.SamplingConfig
 import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.common.AttributesBuilder
@@ -23,6 +24,14 @@ internal class OTelMobileCallSink(
 
     private val liveSpans = HashMap<String, io.opentelemetry.api.trace.Span>()
 
+    // Async gauges must be registered exactly ONCE per metric name. Calling
+    // buildWithCallback on every event leaks a new never-closed observable +
+    // a retained closure each time. We register one observable gauge per name
+    // and have its callback report the latest value/attributes stored here.
+    private val gaugeRegistered = java.util.concurrent.ConcurrentHashMap<String, Boolean>()
+    private val gaugeLatest =
+        java.util.concurrent.ConcurrentHashMap<String, Pair<Double, Attributes>>()
+
     override fun start(config: StartConfig) {
         val app = appContext.applicationContext as android.app.Application
         // Build optional auth + dataset headers. Dash0's OTLP/HTTP ingress
@@ -48,11 +57,45 @@ internal class OTelMobileCallSink(
                 // time. CONDITIONAL buffers spans for up to 1 hour, which is
                 // surprising behavior for a JS dev who just called startSpan().
                 exportMode = io.opentelemetry.android.mobile.config.ExportMode.CONTINUOUS,
+                // RN sampling default is ALWAYS_ON (Loper finding #4): RN manual
+                // spans are root spans with arbitrary names, so the native SDK's
+                // dynamic(0.1) default would silently drop ~90% of a user's first
+                // span. The JS bridge sends always_on unless the caller opts into
+                // sampling; rate-limiting for RN belongs in the collector.
+                samplingConfig = samplingConfigOf(config.sampling),
                 extraResourceAttributes = config.extraResourceAttributes,
             ),
         )
+
+        // Arm the native OkHttp interceptor now that OTelMobile is up and a
+        // tracer exists. The interceptor was installed on RN's OkHttp client
+        // pre-JS (Dash0MobilePackage) but stayed a pass-through no-op until
+        // this moment. Pass the collector endpoint so the interceptor adds our
+        // own ingress host to its ignore list — we must never instrument (or
+        // recurse on) telemetry exports. Wrapped defensively: a failure to arm
+        // network capture must not fail `Dash0Mobile.start`.
+        try {
+            NetworkInstrumentation.interceptor.arm(
+                tracer = OTelMobile.getTracer(SCOPE),
+                collectorEndpoint = config.endpoint,
+            )
+        } catch (_: Throwable) {
+            // No native network capture this session — but start() still
+            // succeeds and JS-side telemetry keeps working.
+        }
     }
 
+    private fun samplingConfigOf(sampling: BridgeSamplingConfig?): SamplingConfig =
+        when (sampling?.strategy) {
+            null,
+            SamplingStrategy.ALWAYS_ON -> SamplingConfig.alwaysOn()
+            SamplingStrategy.ALWAYS_OFF -> SamplingConfig.alwaysOff()
+            SamplingStrategy.DYNAMIC -> SamplingConfig.dynamic(
+                normalRate = sampling.normalRate ?: 0.05,
+                highPriorityRate = sampling.highPriorityRate ?: 1.0,
+            )
+        }
+
     override fun emitLog(
         name: String,
         severity: Int,
@@ -119,7 +162,18 @@ internal class OTelMobileCallSink(
         when (instrumentType) {
             "counter" -> meter.counterBuilder(name).build().add(value.toLong(), otelAttrs)
             "histogram" -> meter.histogramBuilder(name).build().record(value, otelAttrs)
-            "gauge" -> meter.gaugeBuilder(name).buildWithCallback { obs -> obs.record(value, otelAttrs) }
+            "gauge" -> {
+                // Stash the latest reading, then register the observable gauge
+                // ONCE per name. The callback re-reads from gaugeLatest on each
+                // collection so we don't leak a closure/instrument per event.
+                gaugeLatest[name] = value to otelAttrs
+                gaugeRegistered.computeIfAbsent(name) { gaugeName ->
+                    meter.gaugeBuilder(gaugeName).buildWithCallback { obs ->
+                        gaugeLatest[gaugeName]?.let { (v, a) -> obs.record(v, a) }
+                    }
+                    true
+                }
+            }
             else -> Unit
         }
     }
@@ -135,6 +189,12 @@ internal class OTelMobileCallSink(
     }
 
     override fun shutdown() {
+        // Return the interceptor to pass-through BEFORE stopping the SDK so no
+        // in-flight request tries to start a span on a torn-down tracer.
+        try {
+            NetworkInstrumentation.interceptor.disarm()
+        } catch (_: Throwable) {
+        }
         OTelMobile.stop()
     }
 

package/android/src/main/java/com/dash0/mobile/reactnative/OTelNetworkInterceptor.kt

@@ -0,0 +1,206 @@
+/*
+ * OTelNetworkInterceptor — the Android network-instrumentation story for
+ * @dash0/mobile-react-native.
+ *
+ * WHY NATIVE (and not the JS XHR/fetch shim):
+ *   Expo SDK 52+ replaces the global `fetch` with `expo/fetch`, which is
+ *   implemented natively on OkHttp rather than on `XMLHttpRequest`. The JS
+ *   `fetch`/`XHR` shims therefore see ZERO traffic in Expo apps. Installing an
+ *   OkHttp `Interceptor` on React Native's shared OkHttp client captures every
+ *   outbound request — classic `fetch`, `XMLHttpRequest`, axios, AND `expo/fetch`
+ *   — because they all bottom out on that one client.
+ *
+ * WHAT IT DOES, per request:
+ *   1. Records a native CLIENT span (name, http.request.method, url.full,
+ *      server.address, http.response.status_code, timing).
+ *   2. Injects a W3C `traceparent` header built from the REAL native span
+ *      context (trace id + span id + sampled flag), so mobile→backend
+ *      distributed traces stitch on Android the same way iOS's
+ *      OTelURLProtocol stitches them.
+ *
+ * HOST SAFETY (non-negotiable):
+ *   This interceptor wraps the host app's ENTIRE OkHttp pipeline. If it ever
+ *   throws, it breaks ALL networking. So every telemetry operation is wrapped
+ *   such that `chain.proceed(request)` ALWAYS runs and the original
+ *   response/exception is ALWAYS returned. Telemetry failure = drop telemetry,
+ *   never affect the host request.
+ *
+ * LIFECYCLE:
+ *   The interceptor is registered on RN's OkHttpClientProvider BEFORE any JS
+ *   runs (in Dash0MobilePackage.createNativeModules) so expo/fetch's OkHttp
+ *   client picks it up. At that point no tracer exists yet, so it is armed via
+ *   [arm] when the sink's `start` runs (which is what stands up OTelMobile and
+ *   hence the tracer). Before [arm], and after [disarm], it is a pure
+ *   pass-through no-op.
+ */
+package com.dash0.mobile.reactnative
+
+import io.opentelemetry.api.trace.Span
+import io.opentelemetry.api.trace.SpanKind
+import io.opentelemetry.api.trace.StatusCode
+import io.opentelemetry.api.trace.Tracer
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+import okhttp3.Interceptor
+import okhttp3.Response
+
+// Public (not `internal`) because it is exposed through the public
+// `NetworkInstrumentation.interceptor` property; an `internal` type behind a
+// public property is a Kotlin "exposes internal type" compile error.
+class OTelNetworkInterceptor : Interceptor {
+
+    /**
+     * Everything the interceptor needs to produce telemetry. Held behind a
+     * single immutable reference swapped atomically by [arm] / [disarm] so the
+     * intercept path reads a consistent snapshot without locking. `null` = not
+     * yet armed (or shut down) → pure pass-through.
+     */
+    private class Armament(
+        val tracer: Tracer,
+        /** Lower-cased collector hosts that must NOT be instrumented (our own exports). */
+        val ignoredHosts: Set<String>,
+    )
+
+    private val armament = AtomicReference<Armament?>(null)
+
+    /**
+     * Arm the interceptor with a tracer once the sink has started OTelMobile.
+     * Called from [OTelMobileCallSink.start]. The `collectorEndpoint` is the
+     * configured OTLP endpoint; its host is added to the ignore list so we do
+     * not instrument (and recurse on) our own telemetry exports.
+     */
+    fun arm(tracer: Tracer, collectorEndpoint: String?) {
+        val ignored = buildSet {
+            hostFromUrl(collectorEndpoint)?.let { add(it) }
+        }
+        armament.set(Armament(tracer, ignored))
+    }
+
+    /** Return to pass-through. Called on sink shutdown. */
+    fun disarm() {
+        armament.set(null)
+    }
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val active = armament.get()
+            ?: return chain.proceed(chain.request())
+
+        // From here on, EVERY telemetry step is fault-isolated. The original
+        // request must always be proceeded, and the original response (or
+        // exception) must always be returned to the host.
+
+        val originalRequest = chain.request()
+
+        // Decide whether to instrument at all. A throw while computing this
+        // must not stop the request — fall back to "don't instrument".
+        val host: String? = try {
+            originalRequest.url.host.lowercase()
+        } catch (_: Throwable) {
+            null
+        }
+        val shouldInstrument = try {
+            host == null || !active.ignoredHosts.contains(host)
+        } catch (_: Throwable) {
+            false
+        }
+
+        if (!shouldInstrument) {
+            return chain.proceed(originalRequest)
+        }
+
+        // Start the span + build the traceparent-augmented request. If ANY of
+        // this throws, we proceed with the ORIGINAL request and skip telemetry.
+        var span: Span? = null
+        val outgoing = try {
+            val method = originalRequest.method.uppercase()
+            val url = originalRequest.url
+            val startedSpan = active.tracer
+                .spanBuilder(method)
+                .setSpanKind(SpanKind.CLIENT)
+                .startSpan()
+            span = startedSpan
+            startedSpan.setAttribute("http.request.method", method)
+            startedSpan.setAttribute("url.full", url.toString())
+            startedSpan.setAttribute("server.address", url.host)
+            startedSpan.setAttribute("url.scheme", url.scheme)
+
+            val traceparent = traceparentOf(startedSpan)
+            if (traceparent != null) {
+                originalRequest.newBuilder()
+                    .header("traceparent", traceparent)
+                    .build()
+            } else {
+                originalRequest
+            }
+        } catch (_: Throwable) {
+            // Telemetry setup failed. Make sure any half-started span is closed
+            // (best-effort) and proceed cleanly with the untouched request.
+            try {
+                span?.end()
+            } catch (_: Throwable) {
+            }
+            return chain.proceed(originalRequest)
+        }
+
+        // THE host request. This is the one call that must propagate its result
+        // (response OR exception) verbatim to the host. We time it and enrich
+        // the span around it, but never let enrichment alter the outcome.
+        val startNanos = System.nanoTime()
+        val response: Response
+        try {
+            response = chain.proceed(outgoing)
+        } catch (t: Throwable) {
+            // Network failure: record it on the span (best-effort) then rethrow
+            // the ORIGINAL throwable so the host sees the real error.
+            try {
+                span?.setStatus(StatusCode.ERROR, t.javaClass.simpleName)
+                span?.end()
+            } catch (_: Throwable) {
+            }
+            throw t
+        }
+
+        // Success path: enrich + end the span. A throw here must NOT corrupt the
+        // response we hand back to the host.
+        try {
+            val durationMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNanos)
+            val code = response.code
+            span?.setAttribute("http.response.status_code", code.toLong())
+            span?.setAttribute("http.client.request.duration_ms", durationMs)
+            if (code >= 400) {
+                span?.setStatus(StatusCode.ERROR, "HTTP $code")
+            } else {
+                span?.setStatus(StatusCode.OK)
+            }
+            span?.end()
+        } catch (_: Throwable) {
+            // Telemetry finalization failed — drop it, keep the response.
+        }
+
+        return response
+    }
+
+    private companion object {
+        private val HOST_PATTERN =
+            Regex("^[a-z][a-z0-9+.-]*://([^/:?#]+)", RegexOption.IGNORE_CASE)
+
+        /**
+         * W3C traceparent: `00-<32hex traceId>-<16hex spanId>-<2hex flags>`.
+         * Built from the REAL native span context so the backend stitches the
+         * mobile CLIENT span to its SERVER span. Returns null for an invalid
+         * context (e.g. a no-op span when sampling is off and the SDK hands back
+         * an invalid context) so we never inject a malformed header.
+         */
+        fun traceparentOf(span: Span): String? {
+            val ctx = span.spanContext
+            if (!ctx.isValid) return null
+            val flags = if (ctx.isSampled) "01" else "00"
+            return "00-${ctx.traceId}-${ctx.spanId}-$flags"
+        }
+
+        fun hostFromUrl(url: String?): String? {
+            if (url == null) return null
+            return HOST_PATTERN.find(url)?.groupValues?.getOrNull(1)?.lowercase()
+        }
+    }
+}

package/android/src/test/java/com/dash0/mobile/reactnative/Dash0MobileModuleTest.kt

@@ -82,6 +82,75 @@ class Dash0MobileModuleTest {
         assertTrue(sink.starts[0].nativeAutoCapture.isEmpty())
     }
 
+    // ── start: sampling (Loper finding #4) ───────────────────────────────
+
+    @Test
+    fun start_decodes_alwaysOff_sampling() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "s",
+            "endpoint", "https://e",
+            "sampling", JavaOnlyMap.of("strategy", "always_off"),
+        )
+        module.start(cfg, RecordingPromise())
+        assertEquals(
+            BridgeSamplingConfig(strategy = SamplingStrategy.ALWAYS_OFF),
+            sink.starts[0].sampling,
+        )
+    }
+
+    @Test
+    fun start_decodes_dynamic_sampling_with_rates() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "s",
+            "endpoint", "https://e",
+            "sampling", JavaOnlyMap.of(
+                "strategy", "dynamic",
+                "normalRate", 0.1,
+                "highPriorityRate", 1.0,
+            ),
+        )
+        module.start(cfg, RecordingPromise())
+        assertEquals(
+            BridgeSamplingConfig(
+                strategy = SamplingStrategy.DYNAMIC,
+                normalRate = 0.1,
+                highPriorityRate = 1.0,
+            ),
+            sink.starts[0].sampling,
+        )
+    }
+
+    @Test
+    fun start_decodes_alwaysOn_sampling() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "s",
+            "endpoint", "https://e",
+            "sampling", JavaOnlyMap.of("strategy", "always_on"),
+        )
+        module.start(cfg, RecordingPromise())
+        assertEquals(SamplingStrategy.ALWAYS_ON, sink.starts[0].sampling?.strategy)
+    }
+
+    @Test
+    fun start_sampling_null_when_absent() {
+        // The JS bridge always sends `sampling`, but a missing field decodes
+        // to null (the sink then applies the RN ALWAYS_ON default).
+        val cfg = JavaOnlyMap.of("serviceName", "s", "endpoint", "https://e")
+        module.start(cfg, RecordingPromise())
+        assertNull(sink.starts[0].sampling)
+    }
+
+    @Test
+    fun start_unknown_sampling_strategy_falls_back_to_alwaysOn() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "s",
+            "endpoint", "https://e",
+            "sampling", JavaOnlyMap.of("strategy", "martian"),
+        )
+        module.start(cfg, RecordingPromise())
+        assertEquals(SamplingStrategy.ALWAYS_ON, sink.starts[0].sampling?.strategy)
+    }
+
     @Test
     fun start_rejects_when_serviceName_missing() {
         val cfg = JavaOnlyMap.of("endpoint", "e")
@@ -395,18 +464,24 @@ private class RecordingSink : BridgeCallSink {
     }
 }
 
+// Mirrors the react-android 0.76.0 Kotlin `Promise` interface exactly. That
+// interface declares `code` and `userInfo` as NON-null (it is Promise.kt, not
+// the older Java Promise where everything was a nullable platform type), so the
+// override signatures must use non-null `String` / `WritableMap` or Kotlin
+// reports "overrides nothing".
 private class RecordingPromise : Promise {
     var resolved = false
     var rejected = false
     override fun resolve(value: Any?) { resolved = true }
-    override fun reject(code: String?, message: String?) { rejected = true }
-    override fun reject(code: String?, throwable: Throwable?) { rejected = true }
-    override fun reject(code: String?, message: String?, throwable: Throwable?) { rejected = true }
+    override fun reject(code: String, message: String?) { rejected = true }
+    override fun reject(code: String, throwable: Throwable?) { rejected = true }
+    override fun reject(code: String, message: String?, throwable: Throwable?) { rejected = true }
     override fun reject(throwable: Throwable) { rejected = true }
     override fun reject(throwable: Throwable, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
-    override fun reject(code: String?, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
-    override fun reject(code: String?, throwable: Throwable?, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
-    override fun reject(code: String?, message: String?, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
+    override fun reject(code: String, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
+    override fun reject(code: String, throwable: Throwable?, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
+    override fun reject(code: String, message: String?, userInfo: com.facebook.react.bridge.WritableMap) { rejected = true }
+    // The 4-arg overload is declared with all-nullable params in 0.76's Promise.kt.
     override fun reject(code: String?, message: String?, throwable: Throwable?, userInfo: com.facebook.react.bridge.WritableMap?) { rejected = true }
     @Suppress("DEPRECATION")
     override fun reject(message: String) { rejected = true }