@barrysolomon/mobile-react-native 0.1.1-alpha → 0.2.1-alpha

package/android/gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

package/android/settings.gradle

@@ -0,0 +1,62 @@
+/*
+ * Standalone Gradle settings for the @dash0/mobile-react-native Android module.
+ *
+ * WHY THIS EXISTS:
+ *   When consumed by a host React Native app, this module is wired into the
+ *   host's Gradle build via RN autolinking — the host buildscript supplies the
+ *   Android Gradle Plugin + Kotlin plugin versions and the repositories. That
+ *   means the module's Kotlin unit tests (src/test/**) ran NOWHERE in isolation;
+ *   CI's react-native job was jest-only and the native interceptor that wraps
+ *   the host's entire OkHttp pipeline shipped without a runnable test.
+ *
+ *   This file makes the module a self-contained Gradle build so
+ *   `./gradlew :testDebugUnitTest` runs the src/test Kotlin on a pure JVM with
+ *   no emulator. It supplies exactly what autolinking would otherwise inject:
+ *   the plugin versions (pluginManagement) and the dependency repositories,
+ *   including Maven Central where React Native publishes `react-android` and
+ *   where the OkHttp / OpenTelemetry artifacts live.
+ *
+ *   The shipping `build.gradle` is unchanged in spirit — it still applies the
+ *   AGP + Kotlin plugins by id without hardcoding classpath versions, exactly
+ *   as a host-autolinked build expects. The versions are pinned HERE so they
+ *   only affect the standalone test build, never a host consumer.
+ */
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    plugins {
+        // AGP 8.11.x runs on the demo-app's Gradle 9.1.0 (and thus JDK 25)
+        // while still using the standalone kotlin-android plugin. AGP 9.x was
+        // rejected here: its built-in Kotlin integration registers its own
+        // `kotlin` extension and clashes with org.jetbrains.kotlin.android
+        // ("extension already registered with name 'kotlin'").
+        id 'com.android.library' version '8.11.1'
+        id 'org.jetbrains.kotlin.android' version '2.1.20'
+    }
+}
+
+dependencyResolutionManagement {
+    // The module's own build.gradle declares google()/mavenCentral() in a
+    // `repositories {}` block (it must, to stay autolinking-friendly), so do
+    // NOT fail on project repos here.
+    repositoriesMode.set(RepositoriesMode.PREFER_PROJECT)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = 'dash0-mobile-react-native-android'
+
+// react-android 0.76 + the OTel SDK pull androidx.core 1.17.x transitively,
+// which requires compiling against android-36. The shipping build.gradle reads
+// the compileSdk/targetSdk from rootProject.ext (defaulting to 34 for old host
+// consumers); set them here for the standalone test build only, without
+// touching that host-facing default.
+gradle.rootProject {
+    ext.compileSdkVersion = 36
+    ext.targetSdkVersion = 36
+}

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

@@ -64,4 +64,46 @@ data class StartConfig(
      * sink will translate them the same way the iOS sink does today.
      */
     val nativeAutoCapture: List<String> = emptyList(),
+    /**
+     * Trace sampling strategy from the JS caller, mapped onto the native
+     * [io.opentelemetry.android.mobile.sampling.SamplingConfig].
+     *
+     * The RN bridge defaults this to [SamplingStrategy.ALWAYS_ON] when the
+     * JS caller omits `sampling`, rather than inheriting the native SDK's
+     * `dynamic(0.1)` default. RN manual spans are root spans with arbitrary
+     * names, so a 10% baseline silently drops ~90% of a user's first span
+     * (Loper finding #4). Null here means "caller said nothing" — the sink
+     * leaves the native default untouched, but in practice the JS bridge
+     * always sends a value.
+     */
+    val sampling: BridgeSamplingConfig? = null,
 )
+
+/**
+ * Bridge-side mirror of the JS `SamplingConfig`. Decoded from the RN
+ * `start()` payload and translated to the native SDK's `SamplingConfig` in
+ * [OTelMobileCallSink.start].
+ */
+data class BridgeSamplingConfig(
+    val strategy: SamplingStrategy,
+    /** Baseline rate for [SamplingStrategy.DYNAMIC]. Null = native default. */
+    val normalRate: Double? = null,
+    /** High-priority rate for [SamplingStrategy.DYNAMIC]. Null = native default. */
+    val highPriorityRate: Double? = null,
+)
+
+enum class SamplingStrategy {
+    ALWAYS_ON,
+    ALWAYS_OFF,
+    DYNAMIC,
+    ;
+
+    companion object {
+        /** Maps the JS `strategy` string; unknown values fall back to ALWAYS_ON (RN default). */
+        fun fromToken(raw: String?): SamplingStrategy = when (raw) {
+            "always_off" -> ALWAYS_OFF
+            "dynamic" -> DYNAMIC
+            else -> ALWAYS_ON
+        }
+    }
+}

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()
     }