@goliapkg/sentori-react-native 6.1.0 → 6.2.1

package/android/src/main/java-core/com/sentori/SentoriTransport.kt

@@ -0,0 +1,383 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriTransport.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * The only place the SDK talks to the network.
+ *
+ * Ported from `sdk/react-native/src/transport.ts` and matching the
+ * Swift one: batch on a 5 s timer or a 10-deep queue, whichever comes
+ * first; three attempts with a doubling delay; a 429 waits out
+ * `retryAfterMs`; anything left after that spills to disk and drains
+ * on the next launch.
+ *
+ * The iron rule is harder here than in JavaScript. A JS verb returns
+ * because everything after it is a microtask; the JVM has no such
+ * floor, so "fire and forget" is a real queue on a real background
+ * thread. [enqueue] does one bounded append under a lock and returns —
+ * no encoding, no I/O.
+ *
+ * `HttpURLConnection` rather than OkHttp: a monitoring SDK that drags
+ * a networking library into every host app has already broken the
+ * footprint half of its own contract, and OkHttp would also mean this
+ * SDK's traffic goes through the same interceptors the host installed
+ * for its own — which is a surprising place for a crash report to be
+ * logged, retried or blocked.
+ */
+object SentoriTransport {
+
+    private const val FLUSH_INTERVAL_MS = 5_000L
+    private const val BATCH_SIZE = 10
+    private const val MAX_RETRY = 3
+    private const val MAX_PERSISTED = 1000
+
+    /**
+     * Bounded, because an unbounded in-memory queue is a leak with a
+     * nicer name. Past it the oldest go: a crash from ten minutes ago
+     * matters less than the one happening now.
+     */
+    private const val MAX_QUEUED = 500
+
+    private val lock = Any()
+    private val queue = ArrayDeque<Map<String, Any?>>()
+    private val assertStats = mutableMapOf<String, MutableMap<String, Any?>>()
+    private var started = false
+    private var dropped = 0
+    private var delivered = 0
+    private var pending: ScheduledFuture<*>? = null
+
+    /** Where the spill lives. Set by [start]; null keeps it in memory only. */
+    private var spillDir: File? = null
+
+    private val worker: ScheduledExecutorService =
+        Executors.newSingleThreadScheduledExecutor { r ->
+            Thread(r, "sentori-transport").apply { isDaemon = true }
+        }
+
+    /** O(1) on the calling thread: append, maybe schedule. */
+    @JvmStatic
+    fun enqueue(event: Map<String, Any?>) {
+        val due: Boolean
+        synchronized(lock) {
+            queue.addLast(event)
+            while (queue.size > MAX_QUEUED) {
+                queue.removeFirst()
+                dropped += 1
+            }
+            due = queue.size >= BATCH_SIZE
+        }
+        if (due) worker.execute { flush() } else scheduleFlush(FLUSH_INTERVAL_MS)
+    }
+
+    /**
+     * Assert outcomes aggregate rather than becoming events, and ride
+     * whatever batch goes out next — the liveness ledger without a
+     * heartbeat flood.
+     */
+    @JvmStatic
+    fun countAssert(name: String, ok: Boolean, release: String) {
+        val idle: Boolean
+        synchronized(lock) {
+            val key = "$name$release"
+            val stat =
+                assertStats.getOrPut(key) {
+                    mutableMapOf(
+                        "name" to name,
+                        "release" to release,
+                        "passDelta" to 0,
+                        "failDelta" to 0,
+                    )
+                }
+            val field = if (ok) "passDelta" else "failDelta"
+            stat[field] = (stat[field] as Int) + 1
+            idle = queue.isEmpty()
+        }
+        if (idle) scheduleFlush(FLUSH_INTERVAL_MS * 6)
+    }
+
+    @JvmStatic
+    @JvmOverloads
+    fun start(spill: File? = null) {
+        synchronized(lock) {
+            started = true
+            spillDir = spill
+        }
+        worker.execute { drainPersisted() }
+    }
+
+    @JvmStatic
+    fun flush() {
+        // Before touching the queue, not after: draining first and
+        // checking second destroys anything enqueued before init.
+        val config = SentoriConfig.current ?: return
+
+        val events: List<Map<String, Any?>>
+        val stats: List<Map<String, Any?>>
+        val lost: Int
+        synchronized(lock) {
+            if (!started || (queue.isEmpty() && assertStats.isEmpty())) return
+            events = queue.toList()
+            stats = assertStats.values.map { it.toMap() }
+            lost = dropped
+            queue.clear()
+            assertStats.clear()
+            dropped = 0
+            pending?.cancel(false)
+            pending = null
+        }
+
+        val envelope = mutableMapOf<String, Any?>("events" to events)
+        if (stats.isNotEmpty()) envelope["assertStats"] = stats
+        config.backendHealthUrl?.let { envelope["backendHealthUrl"] = it }
+        // Say so rather than let the gap look like quiet: a hole in a
+        // timeline otherwise reads as a calm period.
+        if (lost > 0) envelope["droppedEvents"] = lost
+
+        worker.execute {
+            when (sendWithRetry(envelope, config)) {
+                Outcome.DELIVERED -> synchronized(lock) { delivered += events.size }
+                // Handled, but not accepted. Nothing to retry and
+                // nothing to count.
+                Outcome.DROPPED -> Unit
+                else -> persist(events)
+            }
+        }
+    }
+
+    // ── the network ───────────────────────────────────────────────
+
+    private enum class Outcome {
+        DELIVERED,
+        DROPPED,
+        RETRY_AFTER,
+        FAILED,
+    }
+
+    private var lastRetryAfterMs = 5_000L
+
+    /**
+     * Returns the terminal outcome rather than a bool. "Stop trying"
+     * would conflate a 2xx with a 4xx — not worth retrying is not the
+     * same as delivered, and a counter built on the bool counts a
+     * rejected batch as a success.
+     */
+    private fun sendWithRetry(envelope: Map<String, Any?>, config: SentoriConfig): Outcome {
+        var delay = 1_000L
+        repeat(MAX_RETRY) { attempt ->
+            when (val outcome = sendOnce(envelope, config)) {
+                Outcome.DELIVERED,
+                Outcome.DROPPED -> return outcome
+                Outcome.RETRY_AFTER -> {
+                    if (attempt == MAX_RETRY - 1) return outcome
+                    sleep(lastRetryAfterMs)
+                }
+                Outcome.FAILED -> {
+                    if (attempt == MAX_RETRY - 1) return outcome
+                    sleep(delay)
+                    delay *= 2
+                }
+            }
+        }
+        return Outcome.FAILED
+    }
+
+    private fun sendOnce(envelope: Map<String, Any?>, config: SentoriConfig): Outcome {
+        val body =
+            try {
+                toJson(envelope).toString()
+            } catch (_: Throwable) {
+                // Unencodable content is our problem, not the host's,
+                // and it will not become encodable on a retry.
+                return Outcome.DROPPED
+            }
+
+        var conn: HttpURLConnection? = null
+        return try {
+            conn = URL("${config.ingestUrl}/v1/events:batch").openConnection() as HttpURLConnection
+            conn.requestMethod = "POST"
+            conn.setRequestProperty("Content-Type", "application/json")
+            conn.setRequestProperty("Authorization", "Bearer ${config.token}")
+            conn.setRequestProperty("Sentori-Sdk", "kotlin/${SentoriVersion.CURRENT}")
+            conn.connectTimeout = 15_000
+            conn.readTimeout = 15_000
+            conn.doOutput = true
+            conn.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+
+            when (val code = conn.responseCode) {
+                in 200..299 -> Outcome.DELIVERED
+                429 -> {
+                    lastRetryAfterMs =
+                        try {
+                            val text = conn.errorStream?.bufferedReader()?.readText().orEmpty()
+                            JSONObject(text).optLong("retryAfterMs", 5_000L)
+                        } catch (_: Throwable) {
+                            5_000L
+                        }
+                    Outcome.RETRY_AFTER
+                }
+                in 500..599 -> Outcome.FAILED
+                else -> {
+                    // 4xx other than 429: our request is wrong and
+                    // will be wrong again. Per-item outcomes are the
+                    // server's business.
+                    if (code >= 400) Outcome.DROPPED else Outcome.FAILED
+                }
+            }
+        } catch (_: Throwable) {
+            Outcome.FAILED
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    private fun sleep(ms: Long) {
+        try {
+            TimeUnit.MILLISECONDS.sleep(ms)
+        } catch (_: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+    }
+
+    // ── json ──────────────────────────────────────────────────────
+
+    /**
+     * Hand-rolled rather than a serialization library, for the same
+     * reason as `HttpURLConnection`: `org.json` is in the platform, so
+     * it costs the host nothing.
+     */
+    internal fun toJson(value: Any?): Any {
+        return when (value) {
+            null -> JSONObject.NULL
+            is Map<*, *> -> {
+                val o = JSONObject()
+                for ((k, v) in value) o.put(k.toString(), toJson(v))
+                o
+            }
+            is List<*> -> {
+                val a = JSONArray()
+                for (v in value) a.put(toJson(v))
+                a
+            }
+            is Number, is Boolean, is String -> value
+            else -> value.toString()
+        }
+    }
+
+    // ── the offline queue ─────────────────────────────────────────
+
+    private fun spillFile(): File? {
+        val dir = synchronized(lock) { spillDir } ?: return null
+        if (!dir.exists()) dir.mkdirs()
+        return File(dir, "pending-events.json")
+    }
+
+    private fun persist(events: List<Map<String, Any?>>) {
+        val file = spillFile() ?: return
+        try {
+            val all = readPersisted().toMutableList()
+            all.addAll(events)
+            // Newest wins: the file has to stop growing on a device
+            // that is offline for a week.
+            while (all.size > MAX_PERSISTED) all.removeAt(0)
+            file.writeText(toJson(all).toString())
+        } catch (_: Throwable) {
+            // A full disk must not become the host's problem.
+        }
+    }
+
+    private fun readPersisted(): List<Map<String, Any?>> {
+        val file = spillFile() ?: return emptyList()
+        if (!file.exists()) return emptyList()
+        return try {
+            val arr = JSONArray(file.readText())
+            (0 until arr.length()).map { fromJson(arr.getJSONObject(it)) }
+        } catch (_: Throwable) {
+            emptyList()
+        }
+    }
+
+    private fun fromJson(o: JSONObject): Map<String, Any?> {
+        val out = mutableMapOf<String, Any?>()
+        for (k in o.keys()) {
+            out[k] =
+                when (val v = o.get(k)) {
+                    is JSONObject -> fromJson(v)
+                    JSONObject.NULL -> null
+                    else -> v
+                }
+        }
+        return out
+    }
+
+    /**
+     * Read the spill, clear it, put the events back through the normal
+     * path — clearing first, so a batch that fails again spills once
+     * rather than doubling.
+     */
+    private fun drainPersisted() {
+        val pendingEvents = readPersisted()
+        if (pendingEvents.isEmpty()) return
+        spillFile()?.delete()
+        pendingEvents.forEach { enqueue(it) }
+        flush()
+    }
+
+    // ── timer ─────────────────────────────────────────────────────
+
+    private fun scheduleFlush(afterMs: Long) {
+        synchronized(lock) {
+            if (pending != null) return
+            pending =
+                worker.schedule(
+                    {
+                        synchronized(lock) { pending = null }
+                        flush()
+                    },
+                    afterMs,
+                    TimeUnit.MILLISECONDS,
+                )
+        }
+    }
+
+    // ── test seams ────────────────────────────────────────────────
+
+    internal fun resetForTests() {
+        synchronized(lock) {
+            spillFile()?.delete()
+            queue.clear()
+            assertStats.clear()
+            dropped = 0
+            delivered = 0
+            started = false
+            pending?.cancel(false)
+            pending = null
+            spillDir = null
+        }
+    }
+
+    internal fun peekQueue(): List<Map<String, Any?>> = synchronized(lock) { queue.toList() }
+
+    internal fun peekAssertStats(): List<Map<String, Any?>> =
+        synchronized(lock) { assertStats.values.map { it.toMap() } }
+
+    internal fun peekPersisted(): List<Map<String, Any?>> = readPersisted()
+
+    /**
+     * Events the server actually accepted. A test that checks only for
+     * the absence of a spill passes while retries are still in flight
+     * — which is how the iOS live suite went green against a server
+     * that had stored nothing.
+     */
+    internal fun peekDelivered(): Int = synchronized(lock) { delivered }
+}

package/android/src/test/{java → java-core}/com/sentori/SentoriCrashHandlerTest.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriCrashHandlerTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // Phase 16 sub-E: Robolectric coverage for SentoriCrashHandler (回填 Phase 7).
 //
 // Run via Gradle on the Android host:

package/android/src/test/java-core/com/sentori/SentoriIdentityTest.kt

@@ -0,0 +1,107 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriIdentityTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.io.File
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * The Kotlin hash must equal the TypeScript one for every input, or a
+ * device stops matching the events from the same person and the push
+ * meant for them reaches nobody — silently, on the one path where
+ * nobody is watching.
+ *
+ * The vectors are generated by `sdk/core/src/identity.ts` itself
+ * (`scripts/gen-identity-vectors.mjs`), so this asserts against what
+ * the other implementations actually do rather than against what this
+ * file's author believed they do. It has already earned its keep:
+ * Kotlin's default `trim()` leaves U+00A0 and U+FEFF in place where
+ * JavaScript and Swift strip them, and the vector caught it before it
+ * shipped.
+ */
+@RunWith(RobolectricTestRunner::class)
+class SentoriIdentityTest {
+
+    private fun vectors(): List<Triple<String, String, String>> {
+        // Walk up out of the module to the fixtures shared with iOS.
+        // Robolectric runs with the module directory as CWD; both the
+        // native module and the React Native mirror of it sit three
+        // levels below `sdk`.
+        var dir = File(System.getProperty("user.dir") ?: ".").absoluteFile
+        var fixture: File? = null
+        repeat(8) {
+            val candidate = File(dir, "sdk/native/fixtures/identity-vectors.json")
+            if (candidate.exists()) {
+                fixture = candidate
+                return@repeat
+            }
+            dir = dir.parentFile ?: dir
+        }
+        val f = requireNotNull(fixture) {
+            "identity-vectors.json not found above ${System.getProperty("user.dir")}"
+        }
+        val root = JSONObject(f.readText()).getJSONArray("vectors")
+        return (0 until root.length()).map { i ->
+            val v = root.getJSONObject(i)
+            Triple(v.getString("keyType"), v.getString("raw"), v.getString("sha256Hex"))
+        }
+    }
+
+    @Test
+    fun matchesTheTypeScriptImplementation() {
+        val vectors = vectors()
+        // A fixture that read as empty would pass every assertion
+        // below without running one.
+        assertTrue("fixture looks truncated: ${vectors.size}", vectors.size >= 12)
+        for ((keyType, raw, expected) in vectors) {
+            assertEquals(
+                "$keyType / ${raw.take(40)}",
+                expected,
+                SentoriIdentity.hash(keyType, raw),
+            )
+        }
+    }
+
+    @Test
+    fun emptyAndBlankProduceNoKey() {
+        assertNull(SentoriIdentity.hash("id", ""))
+        assertNull(SentoriIdentity.hash("id", "   "))
+        assertNull(SentoriIdentity.hash("id", null))
+        assertNull(SentoriIdentity.hash("email", " \n "))
+        // A phone with no digits normalises away entirely.
+        assertNull(SentoriIdentity.hash("phone", "(--) --"))
+    }
+
+    @Test
+    fun userKeyPrefersIdAndFallsBackToEmail() {
+        assertEquals(
+            SentoriIdentity.hash("id", "usr_123"),
+            SentoriIdentity.userKey("usr_123", "a@b.com"),
+        )
+        assertEquals(
+            SentoriIdentity.hash("email", "A@B.com"),
+            SentoriIdentity.userKey(null, "A@B.com"),
+        )
+        // A blank id must fall through rather than win and yield null:
+        // `user(id = "")` is a wiring mistake, not a decision to become
+        // unaddressable.
+        assertEquals(
+            SentoriIdentity.hash("email", "a@b.com"),
+            SentoriIdentity.userKey("  ", "a@b.com"),
+        )
+        assertNull(SentoriIdentity.userKey(null, null))
+    }
+
+    @Test
+    fun oauthSubjectsAreLeftExactlyAsGiven() {
+        assertEquals(" Ab ", SentoriIdentity.normalise("googleSub", " Ab "))
+        assertEquals("X.Y", SentoriIdentity.normalise("appleSub", "X.Y"))
+    }
+}

package/android/src/test/java-core/com/sentori/SentoriLiveServerTest.kt

@@ -0,0 +1,106 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/test/java/com/sentori/SentoriLiveServerTest.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.io.File
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Against a real Sentori server, not a mock.
+ *
+ * Everything else in this suite asserts the shape this SDK *builds*.
+ * That is worth nothing if the server rejects it, and a mock would
+ * agree with whatever mistake the SDK is making — which is how a wire
+ * format quietly diverges. The one thing that cannot agree with a
+ * mistake is the server.
+ *
+ * Configuration comes from a file rather than the environment, the
+ * same way the iOS suite reads it, and for the same reason: it was
+ * written once by whoever brought a server up.
+ *
+ * `assumeTrue` skips when there is none. A skip in Gradle's report is
+ * visible; `scripts/android-live-ingest.sh` still fails if this test
+ * did not actually run, because a suite that quietly tested nothing
+ * reports exactly like one that passed.
+ */
+@RunWith(RobolectricTestRunner::class)
+class SentoriLiveServerTest {
+
+    private var base: String? = null
+    private var token: String? = null
+
+    private fun fixture(): File? {
+        var dir = File(System.getProperty("user.dir") ?: ".").absoluteFile
+        repeat(8) {
+            val f = File(dir, "sdk/native/fixtures/live-server.json")
+            if (f.exists()) return f
+            dir = dir.parentFile ?: dir
+        }
+        return null
+    }
+
+    @Before
+    fun setUp() {
+        val f = fixture()
+        assumeTrue("no sdk/native/fixtures/live-server.json — run scripts/android-live-ingest.sh", f != null)
+        val j = JSONObject(f!!.readText())
+        base = j.getString("base")
+        token = j.getString("token")
+        SentoriTransport.resetForTests()
+        SentoriConfig.resetForTests()
+        SentoriScope.clear()
+        SentoriSignalRing.clear()
+    }
+
+    @After
+    fun tearDown() {
+        SentoriTransport.resetForTests()
+        SentoriConfig.resetForTests()
+    }
+
+    @Test
+    fun theServerAcceptsWhatThisSdkSends() {
+        Sentori.start(
+            SentoriConfig(
+                token = token!!,
+                ingestUrl = base!!,
+                release = "kotlin-e2e@1.0.0",
+                environment = "test",
+            )
+        )
+        Sentori.user("usr_kotlin_1", null)
+        Sentori.context(mapOf("tenant" to "acme"))
+        Sentori.pushSignal("nav", mapOf("to" to "/checkout"))
+
+        val id = Sentori.error(IllegalStateException("boom"), mapOf("cartId" to "c_1"))
+        Sentori.warn("checkout.slow", mapOf("ms" to 3200))
+        Sentori.assert("total.positive", false)
+        Sentori.probe("SEN-482")
+        SentoriTransport.flush()
+
+        // Poll for delivery rather than sleeping and checking that
+        // nothing has failed *yet*: both "no spill" and "queue empty"
+        // are true while retries are in flight, and both are true when
+        // the server answers 4xx.
+        val deadline = System.currentTimeMillis() + 30_000
+        while (SentoriTransport.peekDelivered() == 0 && System.currentTimeMillis() < deadline) {
+            Thread.sleep(250)
+        }
+
+        assertTrue(
+            "the server never accepted a batch — spilled: " +
+                "${SentoriTransport.peekPersisted().size}, queued: ${SentoriTransport.peekQueue().size}",
+            SentoriTransport.peekDelivered() > 0,
+        )
+        assertEquals(36, id.length)
+    }
+}