@barrysolomon/mobile-react-native 0.1.0-alpha

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

@@ -0,0 +1,208 @@
+/*
+ * Production BridgeCallSink. Forwards RN bridge calls into the existing
+ * io.opentelemetry.android.mobile.OTelMobile SDK.
+ *
+ * Kept in a separate file from Dash0MobileModule so the module's unit tests
+ * can run under pure JVM (JUnit) without needing to stand up OTelMobile.
+ */
+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.api.common.AttributeKey
+import io.opentelemetry.api.common.Attributes
+import io.opentelemetry.api.common.AttributesBuilder
+import io.opentelemetry.api.logs.Severity
+import io.opentelemetry.api.trace.SpanKind
+import io.opentelemetry.api.trace.StatusCode
+
+internal class OTelMobileCallSink(
+    private val appContext: Context,
+) : BridgeCallSink {
+
+    private val liveSpans = HashMap<String, io.opentelemetry.api.trace.Span>()
+
+    override fun start(config: StartConfig) {
+        val app = appContext.applicationContext as android.app.Application
+        // Build optional auth + dataset headers. Dash0's OTLP/HTTP ingress
+        // requires Bearer auth + the Dash0-Dataset routing header.
+        val headers = buildMap<String, String> {
+            config.authToken?.takeIf { it.isNotBlank() }?.let {
+                put("Authorization", "Bearer $it")
+            }
+            config.dataset?.takeIf { it.isNotBlank() }?.let {
+                put("Dash0-Dataset", it)
+            }
+        }.takeIf { it.isNotEmpty() }
+
+        OTelMobile.start(
+            app,
+            MobileConfig(
+                serviceName = config.serviceName,
+                serviceVersion = config.serviceVersion ?: "unknown",
+                collectorEndpoint = config.endpoint,
+                headers = headers,
+                // RN consumers don't have the same battery concerns as native —
+                // default to CONTINUOUS so traces + metrics flow in reasonable
+                // 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,
+                extraResourceAttributes = config.extraResourceAttributes,
+            ),
+        )
+    }
+
+    override fun emitLog(
+        name: String,
+        severity: Int,
+        attributes: Map<String, Any?>,
+        timeUnixNano: Long,
+    ) {
+        OTelMobile.getLogger(SCOPE)
+            .logRecordBuilder()
+            .setBody(name)
+            .setSeverity(severityOf(severity))
+            .setAllAttributes(attributes.toOtelAttributes())
+            .emit()
+    }
+
+    override fun startSpan(
+        spanId: String,
+        parentSpanId: String?,
+        name: String,
+        spanKind: String,
+        attributes: Map<String, Any?>,
+        startTimeUnixNano: Long,
+    ) {
+        val parent = if (parentSpanId != null) synchronized(liveSpans) { liveSpans[parentSpanId] } else null
+        val builder = OTelMobile.getTracer(SCOPE)
+            .spanBuilder(name)
+            .setSpanKind(spanKindOf(spanKind))
+            .setAllAttributes(attributes.toOtelAttributes())
+        // Propagate parent context so Dash0 renders the waterfall instead
+        // of 14 orphan spans per checkout. `setParent` with an active span
+        // is Context.current()-free and works regardless of thread.
+        if (parent != null) {
+            builder.setParent(io.opentelemetry.context.Context.current().with(parent))
+        }
+        val span = builder.startSpan()
+        synchronized(liveSpans) { liveSpans[spanId] = span }
+    }
+
+    override fun endSpan(
+        spanId: String,
+        status: String,
+        statusMessage: String?,
+        attributes: Map<String, Any?>,
+        endTimeUnixNano: Long,
+    ) {
+        val span = synchronized(liveSpans) { liveSpans.remove(spanId) } ?: return
+        span.setAllAttributes(attributes.toOtelAttributes())
+        when (status) {
+            "OK" -> span.setStatus(StatusCode.OK)
+            "ERROR" -> span.setStatus(StatusCode.ERROR, statusMessage ?: "")
+            else -> Unit
+        }
+        span.end()
+    }
+
+    override fun recordMetric(
+        name: String,
+        instrumentType: String,
+        value: Double,
+        attributes: Map<String, Any?>,
+        timeUnixNano: Long,
+    ) {
+        val meter = OTelMobile.getMeter(SCOPE)
+        val otelAttrs = attributes.toOtelAttributes()
+        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) }
+            else -> Unit
+        }
+    }
+
+    override fun flushWindow(minutes: Int) {
+        try {
+            OTelMobile.getLoggerProvider().getMobileProcessor().flushWindow(minutes)
+        } catch (_: Throwable) {
+            // Bridge contract: flush failures must not surface as JS promise
+            // rejections. The SDK's own retry/disk-buffer path handles
+            // recovery; the RN caller just wants best-effort flush.
+        }
+    }
+
+    override fun shutdown() {
+        OTelMobile.stop()
+    }
+
+    /**
+     * Synchronous drain through the OTLP exporter, persisting any
+     * in-flight records to disk on export failure. Invoked by
+     * [Dash0MobileModule.dispatch] after a FATAL-severity (severity ≥ 21)
+     * log emit so the crash payload lands in Dash0 even when the JS
+     * fatal reporter terminates the process before the periodic flush
+     * timer fires.
+     *
+     * Mirrors iOS commit `39bd258` (library-level FATAL forceFlush).
+     */
+    override fun forceFlush() {
+        try {
+            OTelMobile.getLoggerProvider().getMobileProcessor().forceFlush()
+        } catch (_: Throwable) {
+            // Best-effort: a forceFlush failure on the FATAL path must
+            // never throw out of the dispatcher (we'd lose the rest of
+            // the batch). The SDK's own retry/disk-buffer handles any
+            // export failure under the hood.
+        }
+    }
+
+    companion object {
+        private const val SCOPE = "io.dash0.mobile.reactnative"
+
+        private fun severityOf(n: Int): Severity = when (n) {
+            1 -> Severity.TRACE
+            5 -> Severity.DEBUG
+            9 -> Severity.INFO
+            13 -> Severity.WARN
+            17 -> Severity.ERROR
+            21 -> Severity.FATAL
+            else -> Severity.INFO
+        }
+
+        private fun spanKindOf(s: String): SpanKind = when (s) {
+            "CLIENT" -> SpanKind.CLIENT
+            "SERVER" -> SpanKind.SERVER
+            "PRODUCER" -> SpanKind.PRODUCER
+            "CONSUMER" -> SpanKind.CONSUMER
+            else -> SpanKind.INTERNAL
+        }
+
+        private fun Map<String, Any?>.toOtelAttributes(): Attributes {
+            val b: AttributesBuilder = Attributes.builder()
+            for ((k, v) in this) {
+                when (v) {
+                    is String -> b.put(AttributeKey.stringKey(k), v)
+                    is Boolean -> b.put(AttributeKey.booleanKey(k), v)
+                    is Double -> {
+                        // Route integer-valued doubles to long keys so downstream
+                        // consumers see `qty=2`, not `qty=2.0`. OTel attribute
+                        // conventions use long for whole-number counts.
+                        if (v == v.toLong().toDouble()) {
+                            b.put(AttributeKey.longKey(k), v.toLong())
+                        } else {
+                            b.put(AttributeKey.doubleKey(k), v)
+                        }
+                    }
+                    is Long -> b.put(AttributeKey.longKey(k), v)
+                    is Int -> b.put(AttributeKey.longKey(k), v.toLong())
+                    null -> Unit
+                    else -> b.put(AttributeKey.stringKey(k), v.toString())
+                }
+            }
+            return b.build()
+        }
+    }
+}

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

@@ -0,0 +1,413 @@
+/*
+ * RN-012 unit tests for Dash0MobileModule.
+ *
+ * These tests feed ReadableMap/ReadableArray fixtures into the module and
+ * assert the corresponding BridgeCallSink methods are called with the right
+ * arguments. A fake sink is used so we don't need the real OTelMobile SDK,
+ * an Android emulator, or any RN runtime.
+ *
+ * The cross-bridge contract is the only thing under test here — the OTel
+ * wiring is verified separately in the Android SDK's own test suite.
+ */
+package com.dash0.mobile.reactnative
+
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito.mock
+
+class Dash0MobileModuleTest {
+
+    private lateinit var sink: RecordingSink
+    private lateinit var module: Dash0MobileModule
+
+    @Before
+    fun setUp() {
+        sink = RecordingSink()
+        val ctx = mock(ReactApplicationContext::class.java)
+        module = Dash0MobileModule(ctx, sink)
+    }
+
+    // ── start ────────────────────────────────────────────────────────────
+
+    @Test
+    fun start_forwards_required_and_optional_fields() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "otel-rn-astronomy-shop",
+            "endpoint", "https://ingress/v1/logs",
+            "serviceVersion", "1.2.3",
+            "authToken", "tok",
+            "dataset", "otel-mobile",
+        )
+        val promise = RecordingPromise()
+
+        module.start(cfg, promise)
+
+        assertEquals(1, sink.starts.size)
+        val got = sink.starts[0]
+        assertEquals("otel-rn-astronomy-shop", got.serviceName)
+        assertEquals("https://ingress/v1/logs", got.endpoint)
+        assertEquals("1.2.3", got.serviceVersion)
+        assertEquals("tok", got.authToken)
+        assertEquals("otel-mobile", got.dataset)
+        assertTrue(promise.resolved)
+    }
+
+    @Test
+    fun start_forwards_nativeAutoCapture_tokens() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "s",
+            "endpoint", "https://e",
+            "nativeAutoCapture", JavaOnlyArray.of("vitals", "deviceStats"),
+        )
+        val promise = RecordingPromise()
+        module.start(cfg, promise)
+        assertEquals(listOf("vitals", "deviceStats"), sink.starts[0].nativeAutoCapture)
+    }
+
+    @Test
+    fun start_defaults_nativeAutoCapture_to_empty_when_absent() {
+        val cfg = JavaOnlyMap.of(
+            "serviceName", "s",
+            "endpoint", "https://e",
+        )
+        val promise = RecordingPromise()
+        module.start(cfg, promise)
+        assertTrue(sink.starts[0].nativeAutoCapture.isEmpty())
+    }
+
+    @Test
+    fun start_rejects_when_serviceName_missing() {
+        val cfg = JavaOnlyMap.of("endpoint", "e")
+        val promise = RecordingPromise()
+        module.start(cfg, promise)
+        assertTrue(promise.rejected)
+        assertEquals(0, sink.starts.size)
+    }
+
+    // ── emitBatch: log ───────────────────────────────────────────────────
+
+    @Test
+    fun emitBatch_dispatches_log_payload() {
+        val payload = JavaOnlyMap.of(
+            "kind", "log",
+            "name", "cart.add_item",
+            "severity", 9.0,
+            "timeUnixNano", "1713600000000000000",
+            "attributes", JavaOnlyMap.of(
+                "shop.item_id", "abc",
+                "qty", 2.0,
+                "urgent", true,
+            ),
+        )
+        val batch = JavaOnlyArray.of(payload)
+        val promise = RecordingPromise()
+
+        module.emitBatch(batch, promise)
+
+        assertEquals(1, sink.logs.size)
+        val log = sink.logs[0]
+        assertEquals("cart.add_item", log.name)
+        assertEquals(9, log.severity)
+        assertEquals(1713600000000000000L, log.timeUnixNano)
+        assertEquals("abc", log.attributes["shop.item_id"])
+        assertEquals(2.0, log.attributes["qty"] as Double, 0.0)
+        assertEquals(true, log.attributes["urgent"])
+        assertTrue(promise.resolved)
+    }
+
+    // ── emitBatch: span pair ─────────────────────────────────────────────
+
+    @Test
+    fun emitBatch_dispatches_spanStart_and_spanEnd_with_matching_spanId() {
+        val spanStart = JavaOnlyMap.of(
+            "kind", "spanStart",
+            "spanId", "abc123def456789a",
+            "name", "checkout",
+            "spanKind", "INTERNAL",
+            "startTimeUnixNano", "1713600000000000000",
+            "attributes", JavaOnlyMap.of("shop.cart_size", 3.0),
+        )
+        val spanEnd = JavaOnlyMap.of(
+            "kind", "spanEnd",
+            "spanId", "abc123def456789a",
+            "status", "OK",
+            "endTimeUnixNano", "1713600000050000000",
+            "attributes", JavaOnlyMap.of("http.response.status_code", 200.0),
+        )
+        val batch = JavaOnlyArray.of(spanStart, spanEnd)
+
+        module.emitBatch(batch, RecordingPromise())
+
+        assertEquals(1, sink.spanStarts.size)
+        assertEquals(1, sink.spanEnds.size)
+        assertEquals(sink.spanStarts[0].spanId, sink.spanEnds[0].spanId)
+        assertEquals("checkout", sink.spanStarts[0].name)
+        assertEquals("OK", sink.spanEnds[0].status)
+    }
+
+    @Test
+    fun emitBatch_spanEnd_with_ERROR_carries_statusMessage() {
+        val spanEnd = JavaOnlyMap.of(
+            "kind", "spanEnd",
+            "spanId", "aaaaaaaaaaaaaaaa",
+            "status", "ERROR",
+            "statusMessage", "nope",
+            "endTimeUnixNano", "0",
+            "attributes", JavaOnlyMap.of(),
+        )
+        module.emitBatch(JavaOnlyArray.of(spanEnd), RecordingPromise())
+        assertEquals("ERROR", sink.spanEnds[0].status)
+        assertEquals("nope", sink.spanEnds[0].statusMessage)
+    }
+
+    // ── emitBatch: metric ────────────────────────────────────────────────
+
+    @Test
+    fun emitBatch_dispatches_metric_for_counter_histogram_gauge() {
+        val types = listOf("counter", "histogram", "gauge")
+        val items = types.map { t ->
+            JavaOnlyMap.of(
+                "kind", "metric",
+                "name", "shop.x",
+                "instrumentType", t,
+                "value", 42.5,
+                "timeUnixNano", "0",
+                "attributes", JavaOnlyMap.of(),
+            )
+        }
+        val batch = JavaOnlyArray.of(*items.toTypedArray())
+
+        module.emitBatch(batch, RecordingPromise())
+
+        assertEquals(3, sink.metrics.size)
+        assertEquals(types, sink.metrics.map { it.instrumentType })
+        assertEquals(42.5, sink.metrics[0].value, 0.0)
+    }
+
+    // ── emitBatch: forward-compat ────────────────────────────────────────
+
+    @Test
+    fun emitBatch_silently_drops_unknown_kind() {
+        val weird = JavaOnlyMap.of("kind", "martian", "name", "x")
+        val promise = RecordingPromise()
+        module.emitBatch(JavaOnlyArray.of(weird), promise)
+        assertEquals(0, sink.logs.size + sink.spanStarts.size + sink.spanEnds.size + sink.metrics.size)
+        assertTrue(promise.resolved)
+    }
+
+    // ── flushWindow / shutdown ───────────────────────────────────────────
+
+    @Test
+    fun flushWindow_forwards_minutes_as_int() {
+        val promise = RecordingPromise()
+        module.flushWindow(5.0, promise)
+        assertEquals(listOf(5), sink.flushMinutes)
+        assertTrue(promise.resolved)
+    }
+
+    @Test
+    fun shutdown_forwards_and_resolves() {
+        val promise = RecordingPromise()
+        module.shutdown(promise)
+        assertEquals(1, sink.shutdowns)
+        assertTrue(promise.resolved)
+    }
+
+    @Test
+    fun getName_returns_Dash0Mobile() {
+        assertEquals("Dash0Mobile", module.name)
+    }
+
+    // ── FATAL-severity forceFlush hook ───────────────────────────────────
+
+    @Test
+    fun emitLog_fatalSeverity_triggersForceFlush() {
+        val payload = JavaOnlyMap.of(
+            "kind", "log",
+            "name", "app.error",
+            "severity", 21.0,
+            "attributes", JavaOnlyMap.of(),
+            "timeUnixNano", "1700000000000000000",
+        )
+        module.emitBatch(JavaOnlyArray.of(payload), RecordingPromise())
+
+        assertEquals(1, sink.logs.size)
+        assertEquals(1, sink.forceFlushes)
+    }
+
+    @Test
+    fun emitLog_belowFatal_doesNotTriggerForceFlush() {
+        // 17 = ERROR in OTel semconv. Should NOT flush.
+        val payload = JavaOnlyMap.of(
+            "kind", "log",
+            "name", "app.error",
+            "severity", 17.0,
+            "attributes", JavaOnlyMap.of(),
+            "timeUnixNano", "1700000000000000000",
+        )
+        module.emitBatch(JavaOnlyArray.of(payload), RecordingPromise())
+
+        assertEquals(1, sink.logs.size)
+        assertEquals(0, sink.forceFlushes)
+    }
+
+    @Test
+    fun emitLog_fatalSeverity_flushOrderingIsPostEmitPrePeer() {
+        // FATAL log followed by another payload in the same batch. The
+        // dispatcher must emit the FATAL, force-flush, THEN dispatch
+        // the next payload — never the other way around.
+        val fatal = JavaOnlyMap.of(
+            "kind", "log",
+            "name", "app.error",
+            "severity", 21.0,
+            "attributes", JavaOnlyMap.of(),
+            "timeUnixNano", "1700000000000000000",
+        )
+        val context = JavaOnlyMap.of(
+            "kind", "log",
+            "name", "app.error.context",
+            "severity", 9.0,
+            "attributes", JavaOnlyMap.of(),
+            "timeUnixNano", "1700000000000000001",
+        )
+        module.emitBatch(JavaOnlyArray.of(fatal, context), RecordingPromise())
+
+        assertEquals(
+            listOf(
+                "emitLog(app.error,21)",
+                "forceFlush",
+                "emitLog(app.error.context,9)",
+            ),
+            sink.actionLog,
+        )
+    }
+
+    @Test
+    fun emitLog_multipleFatalsInBatch_eachTriggersFlush() {
+        // Two FATALs in a row — each gets its own flush. Wasteful but
+        // safer than batching: a flush after the first FATAL might
+        // succeed-then-die before reaching the second; flushing after
+        // each ensures both have a chance to reach disk independently.
+        val a = JavaOnlyMap.of(
+            "kind", "log", "name", "a", "severity", 21.0,
+            "attributes", JavaOnlyMap.of(), "timeUnixNano", "1",
+        )
+        val b = JavaOnlyMap.of(
+            "kind", "log", "name", "b", "severity", 22.0,
+            "attributes", JavaOnlyMap.of(), "timeUnixNano", "2",
+        )
+        module.emitBatch(JavaOnlyArray.of(a, b), RecordingPromise())
+
+        assertEquals(2, sink.forceFlushes)
+    }
+
+    @Test
+    fun emitLog_fatalSeverityRangeBoundary() {
+        // OTel semconv: FATAL severity range is 21..24. Anything ≥ 21
+        // is FATAL. The dispatcher's threshold (≥ 21) covers all.
+        val fatal22 = JavaOnlyMap.of(
+            "kind", "log", "name", "fatal2", "severity", 22.0,
+            "attributes", JavaOnlyMap.of(), "timeUnixNano", "1",
+        )
+        val fatal23 = JavaOnlyMap.of(
+            "kind", "log", "name", "fatal3", "severity", 23.0,
+            "attributes", JavaOnlyMap.of(), "timeUnixNano", "2",
+        )
+        val fatal24 = JavaOnlyMap.of(
+            "kind", "log", "name", "fatal4", "severity", 24.0,
+            "attributes", JavaOnlyMap.of(), "timeUnixNano", "3",
+        )
+        val warn = JavaOnlyMap.of(
+            "kind", "log", "name", "warn", "severity", 13.0,
+            "attributes", JavaOnlyMap.of(), "timeUnixNano", "4",
+        )
+        module.emitBatch(
+            JavaOnlyArray.of(fatal22, fatal23, fatal24, warn),
+            RecordingPromise(),
+        )
+
+        assertEquals(3, sink.forceFlushes)
+    }
+}
+
+// ─── test doubles ────────────────────────────────────────────────────────
+
+private data class LogCall(val name: String, val severity: Int, val attributes: Map<String, Any?>, val timeUnixNano: Long)
+private data class SpanStartCall(val spanId: String, val parentSpanId: String?, val name: String, val spanKind: String, val attributes: Map<String, Any?>, val startTimeUnixNano: Long)
+private data class SpanEndCall(val spanId: String, val status: String, val statusMessage: String?, val attributes: Map<String, Any?>, val endTimeUnixNano: Long)
+private data class MetricCall(val name: String, val instrumentType: String, val value: Double, val attributes: Map<String, Any?>, val timeUnixNano: Long)
+
+private class RecordingSink : BridgeCallSink {
+    val starts = mutableListOf<StartConfig>()
+    val logs = mutableListOf<LogCall>()
+    val spanStarts = mutableListOf<SpanStartCall>()
+    val spanEnds = mutableListOf<SpanEndCall>()
+    val metrics = mutableListOf<MetricCall>()
+    val flushMinutes = mutableListOf<Int>()
+    var shutdowns = 0
+    /**
+     * Order of `(action, payloadId)` so the ordering tests can assert
+     * forceFlush runs AFTER the FATAL emit but BEFORE the next payload
+     * — the dispatcher contract is "drain the buffer for the FATAL
+     * before the next payload could clobber it or the process dies."
+     */
+    val actionLog = mutableListOf<String>()
+    var forceFlushes = 0
+
+    override fun start(config: StartConfig) {
+        starts += config
+        actionLog += "start"
+    }
+    override fun emitLog(name: String, severity: Int, attributes: Map<String, Any?>, timeUnixNano: Long) {
+        logs += LogCall(name, severity, attributes, timeUnixNano)
+        actionLog += "emitLog($name,$severity)"
+    }
+    override fun startSpan(spanId: String, parentSpanId: String?, name: String, spanKind: String, attributes: Map<String, Any?>, startTimeUnixNano: Long) {
+        spanStarts += SpanStartCall(spanId, parentSpanId, name, spanKind, attributes, startTimeUnixNano)
+        actionLog += "startSpan($name)"
+    }
+    override fun endSpan(spanId: String, status: String, statusMessage: String?, attributes: Map<String, Any?>, endTimeUnixNano: Long) {
+        spanEnds += SpanEndCall(spanId, status, statusMessage, attributes, endTimeUnixNano)
+        actionLog += "endSpan($spanId)"
+    }
+    override fun recordMetric(name: String, instrumentType: String, value: Double, attributes: Map<String, Any?>, timeUnixNano: Long) {
+        metrics += MetricCall(name, instrumentType, value, attributes, timeUnixNano)
+        actionLog += "recordMetric($name)"
+    }
+    override fun flushWindow(minutes: Int) {
+        flushMinutes += minutes
+        actionLog += "flushWindow($minutes)"
+    }
+    override fun shutdown() {
+        shutdowns += 1
+        actionLog += "shutdown"
+    }
+    override fun forceFlush() {
+        forceFlushes += 1
+        actionLog += "forceFlush"
+    }
+}
+
+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(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?, message: String?, throwable: Throwable?, userInfo: com.facebook.react.bridge.WritableMap?) { rejected = true }
+    @Suppress("DEPRECATION")
+    override fun reject(message: String) { rejected = true }
+}