@goliapkg/sentori-react-native 6.2.0 → 6.2.1

package/SentoriReactNative.podspec

@@ -10,15 +10,22 @@ Pod::Spec.new do |s|
   s.license        = 'TBD'
   s.author         = { 'Sentori' => 'support@sentori.golia.jp' }
   s.homepage       = 'https://sentori.golia.jp'
-  s.platforms      = { ios: '13.4', tvos: '13.4' }
+  # 13.4 was a claim nothing compiled. `SentoriPushNotifications`
+  # uses `UNNotificationPresentationOptions.banner` and `.list`, both
+  # iOS 14 — building the sources against the declared floor for the
+  # first time (as a Swift package, 2026-08-11) failed on exactly
+  # that. The floor now matches what the code needs.
+  s.platforms      = { ios: '14.0', tvos: '14.0' }
   s.swift_version  = '5.4'
   s.source         = { git: '' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
 
+  # `ios/SentoriModule.swift` is the bridge; `ios/core/` is a mirror of
+  # `sdk/native/ios/Sources/Sentori`, written by
+  # `scripts/sync-native-core.mjs` and gated byte-for-byte. Edit the
+  # package, never the mirror — a pod cannot reach outside its own
+  # directory, which is the only reason a copy exists at all.
   s.source_files = 'ios/**/*.{h,m,mm,swift,hpp,cpp}'
-  # XCTest only links into test targets; including ios/Tests/** in the
-  # main pod target makes app builds fail with `no such module 'XCTest'`.
-  s.exclude_files = 'ios/Tests/**'
 end

package/android/build.gradle

@@ -18,7 +18,21 @@ android {
     sourceSets {
         main {
             manifest.srcFile 'src/main/AndroidManifest.xml'
-            java.srcDirs = ['src/main/java']
+            // `java` holds the bridge — `SentoriModule.kt`, the one
+            // file here that knows Expo exists. `java-core` is a
+            // generated mirror of `sdk/native/android`, written by
+            // `scripts/sync-native-core.mjs` and gated byte-for-byte.
+            // Two roots rather than one directory because the sync
+            // deletes its target before writing, and the bridge must
+            // not live somewhere that gets wiped.
+            java.srcDirs = ['src/main/java', 'src/main/java-core']
+        }
+        test {
+            // The Robolectric suites cover the core, so they moved
+            // with it. Mirrored back so `android-unit` keeps running
+            // them — dropping them here would have left the job green
+            // while testing strictly less.
+            java.srcDirs = ['src/test/java', 'src/test/java-core']
         }
     }
 

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

@@ -0,0 +1,244 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/Sentori.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import android.content.Context
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import kotlin.random.Random
+
+/**
+ * The surface a host app writes against.
+ *
+ *     Sentori.error(e)                what went wrong?
+ *     Sentori.warn("checkout.slow")   where did the user struggle?
+ *     Sentori.trace("cart.opened")    what happened here?
+ *     Sentori.assert("total", ok)     should this hold?
+ *     Sentori.probe("SEN-482")        is that bug back?
+ *
+ * Every one is synchronous, returns the event id it minted, and never
+ * throws — including before [start], where each is a no-op that still
+ * hands back an id. An app that mis-wires its token gets a silent SDK,
+ * not an exception on a path it did not know it had.
+ *
+ * Same semantics as the Swift and React Native surfaces, because the
+ * dashboard reading them cannot tell which one sent an event and
+ * should not have to.
+ */
+object Sentori {
+
+    // ── lifecycle ─────────────────────────────────────────────────
+
+    /**
+     * Configure and start. [context] is used for one thing: the
+     * directory events spill into when the network is gone. Pass the
+     * application context, not an Activity.
+     *
+     * Nothing here reaches the network; the first request happens when
+     * there is something to send.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun start(config: SentoriConfig, context: Context? = null) {
+        SentoriConfig.set(config)
+        SentoriDevice.bind(context)
+        SentoriTransport.start(context?.let { java.io.File(it.filesDir, "sentori") })
+    }
+
+    /**
+     * Identify the person using the app. Only a hash of [id] (or
+     * [email] when there is no id) travels; the raw values stay here.
+     *
+     * Call this before registering for push if you want the device to
+     * be reachable from an issue — a device with no user key receives
+     * broadcasts and nothing else.
+     */
+    @JvmStatic
+    fun user(id: String?, email: String?) = SentoriScope.setUser(id, email)
+
+    /** Merge keys into the ambient context that rides every event. */
+    @JvmStatic
+    fun context(patch: Map<String, Any?>) = SentoriScope.patchContext(patch)
+
+    /**
+     * Record a signal for the last-sixty-seconds ring that ships with
+     * an error. Any [kind] is accepted; the dashboard reads `http` as
+     * `{ method, url, status, ms }` and `trace` as a quiet breadcrumb.
+     *
+     * This SDK deliberately does not install an OkHttp interceptor:
+     * watching the host's traffic is the host's decision, not ours to
+     * make silently.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun pushSignal(kind: String, data: Map<String, Any?>? = null) =
+        SentoriSignalRing.push(kind, data)
+
+    /**
+     * `Sentori.push.register(...)`, matching `sentori.push.register()`
+     * in the React Native SDK and `Sentori.push` in Swift.
+     */
+    @JvmStatic val push: SentoriPush get() = SentoriPush
+
+    // ── the verbs ─────────────────────────────────────────────────
+
+    /** Something went wrong. */
+    @JvmStatic
+    @JvmOverloads
+    fun error(err: Throwable, data: Map<String, Any?>? = null): String =
+        emit("error", null, describe(err), data, withSignals = true)
+
+    /** Something went wrong, described rather than thrown. */
+    @JvmStatic
+    @JvmOverloads
+    fun error(message: String, type: String = "Error", data: Map<String, Any?>? = null): String =
+        emit("error", null, mapOf("type" to type, "message" to message), data, withSignals = true)
+
+    /**
+     * The user struggled here. Not a crash — a place the product hurt,
+     * named by you.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun warn(name: String, data: Map<String, Any?>? = null): String =
+        emit("warn", name, null, data, withSignals = true)
+
+    /**
+     * This happened. Always lands in the signal ring; [quiet] keeps it
+     * out of the event stream, which is how a high-frequency
+     * breadcrumb stays affordable.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun trace(name: String, data: Map<String, Any?>? = null, quiet: Boolean = false): String {
+        val signal = mutableMapOf<String, Any?>("name" to name)
+        data?.let { signal.putAll(it) }
+        SentoriSignalRing.push("trace", signal)
+        if (quiet) return newEventId()
+        return emit("trace", name, null, data, withSignals = false)
+    }
+
+    /**
+     * This should hold. A passing assert never becomes an event — it
+     * increments a counter that rides the next batch, so a liveness
+     * check costs no request. Only failures are events.
+     *
+     * Unlike the language's own `assert`, this never stops the
+     * program. That difference is the point: a monitoring SDK that can
+     * halt the app it monitors has picked the wrong side of the
+     * bargain.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun assert(name: String, ok: Boolean, data: Map<String, Any?>? = null): String {
+        SentoriConfig.current?.let { SentoriTransport.countAssert(name, ok, it.release) }
+        if (ok) return newEventId()
+        return emit("assert", name, null, data, withSignals = true)
+    }
+
+    /**
+     * Is that bug back? A tripwire: reaching this call is the signal.
+     * It changes no control flow and returns no verdict.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun probe(ref: String, data: Map<String, Any?>? = null): String =
+        emit("probe", ref, null, data, withSignals = false)
+
+    // ── assembly ──────────────────────────────────────────────────
+
+    private fun emit(
+        kind: String,
+        name: String?,
+        error: Map<String, Any?>?,
+        data: Map<String, Any?>?,
+        withSignals: Boolean,
+    ): String {
+        val id = newEventId()
+        // Before init every verb is a no-op that still returns an id,
+        // so a call site does not change shape depending on whether
+        // the SDK came up.
+        val config = SentoriConfig.current ?: return id
+
+        val payload = mutableMapOf<String, Any?>()
+        error?.let { payload["error"] = it }
+        data?.let { payload["data"] = it }
+        SentoriScope.context?.let { payload["context"] = it }
+        if (withSignals) {
+            val signals = SentoriSignalRing.snapshot()
+            if (signals.isNotEmpty()) payload["signals"] = signals
+        }
+        payload["device"] = SentoriDevice.snapshot()
+
+        val event =
+            mutableMapOf<String, Any?>(
+                "id" to id,
+                "kind" to kind,
+                "occurredAt" to iso8601(Date()),
+                "platform" to "android",
+                "release" to config.release,
+                "environment" to config.environment,
+                "payload" to payload,
+            )
+        name?.let { event["name"] = it }
+        SentoriScope.userKey?.let { event["userKey"] = it }
+
+        SentoriTransport.enqueue(event)
+        return id
+    }
+
+    private fun describe(err: Throwable): Map<String, Any?> {
+        val frames =
+            err.stackTrace.take(50).map { f ->
+                mapOf(
+                    "function" to "${f.className}.${f.methodName}",
+                    "file" to (f.fileName ?: ""),
+                    "line" to f.lineNumber,
+                )
+            }
+        val out =
+            mutableMapOf<String, Any?>(
+                "type" to (err.javaClass.name),
+                "message" to (err.message ?: ""),
+                "stack" to frames,
+            )
+        err.cause?.let { if (it !== err) out["cause"] = describe(it) }
+        return out
+    }
+
+    private val isoFormat =
+        SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply {
+            timeZone = TimeZone.getTimeZone("UTC")
+        }
+
+    internal fun iso8601(date: Date): String = synchronized(isoFormat) { isoFormat.format(date) }
+
+    /**
+     * UUIDv7: 48 bits of milliseconds then random, so ids sort by
+     * creation time. The server keys events on them and the dashboard
+     * orders by them, so a v4 would scatter a session across the
+     * index.
+     */
+    internal fun newEventId(): String {
+        val bytes = ByteArray(16)
+        Random.nextBytes(bytes)
+        val ms = System.currentTimeMillis()
+        bytes[0] = ((ms shr 40) and 0xff).toByte()
+        bytes[1] = ((ms shr 32) and 0xff).toByte()
+        bytes[2] = ((ms shr 24) and 0xff).toByte()
+        bytes[3] = ((ms shr 16) and 0xff).toByte()
+        bytes[4] = ((ms shr 8) and 0xff).toByte()
+        bytes[5] = (ms and 0xff).toByte()
+        bytes[6] = ((bytes[6].toInt() and 0x0f) or 0x70).toByte()
+        bytes[8] = ((bytes[8].toInt() and 0x3f) or 0x80).toByte()
+
+        val hex = StringBuilder(32)
+        for (b in bytes) hex.append(String.format("%02x", b.toInt() and 0xff))
+        val h = hex.toString()
+        return "${h.substring(0, 8)}-${h.substring(8, 12)}-${h.substring(12, 16)}-" +
+            "${h.substring(16, 20)}-${h.substring(20, 32)}"
+    }
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriAnrWatchdog.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriAnrWatchdog.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.content.Context

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

@@ -0,0 +1,61 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriConfig.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Set once by [Sentori.start]; everything else reads it and treats
+ * absence as "not initialised, so every verb is a no-op".
+ *
+ * That default is the failure-isolation half of the client zero-cost
+ * rule: an app that mis-wires its token gets a silent SDK, never an
+ * exception on a path it did not know it had.
+ */
+class SentoriConfig
+@JvmOverloads
+constructor(
+    val token: String,
+    ingestUrl: String,
+    val release: String,
+    val environment: String,
+    /**
+     * The integrator's own health endpoint, carried on batches and
+     * probed server-side. The app never pings it — a monitoring SDK
+     * that adds traffic to the thing it monitors has picked the wrong
+     * side of the bargain.
+     */
+    val backendHealthUrl: String? = null,
+) {
+    /**
+     * A trailing slash here becomes `//v1/events:batch`, which some
+     * proxies answer and some 404.
+     */
+    val ingestUrl: String = ingestUrl.trimEnd('/')
+
+    companion object {
+        private val ref = AtomicReference<SentoriConfig?>(null)
+
+        @JvmStatic val current: SentoriConfig? get() = ref.get()
+
+        @JvmStatic val isInitialised: Boolean get() = ref.get() != null
+
+        internal fun set(config: SentoriConfig?) = ref.set(config)
+
+        internal fun resetForTests() = ref.set(null)
+    }
+}
+
+/**
+ * Reported in the `Sentori-Sdk` header so a server-side problem can be
+ * attributed to a client version.
+ *
+ * Mirrors the constant in `sdk/react-native/src/transport.ts` and the
+ * Swift one, and is written by `scripts/sync-sdk-version.mjs` — a
+ * version string nothing writes goes stale, and only ever in the
+ * direction of a lie.
+ */
+object SentoriVersion {
+    const val CURRENT = "1.0.0"
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriCrashHandler.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriCrashHandler.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.content.Context

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

@@ -0,0 +1,61 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriDevice.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import android.content.Context
+import android.os.Build
+
+/**
+ * What the device is, as `payload.device` on every event.
+ *
+ * Everything here is read once and cached: this runs on the calling
+ * thread inside every verb, and a verb that asks the window manager
+ * for a fresh value each time is not the O(1) the contract promises.
+ */
+object SentoriDevice {
+
+    private val lock = Any()
+    private var screen: Map<String, Any?>? = null
+
+    /**
+     * Optional. Without a [Context] the snapshot omits the screen and
+     * carries everything else — an event with a thinner device beats
+     * no event, and a host that starts the SDK before it has a context
+     * is making a reasonable choice.
+     */
+    @JvmStatic
+    fun bind(context: Context?) {
+        val ctx = context ?: return
+        synchronized(lock) {
+            val m = ctx.resources.displayMetrics
+            screen =
+                mapOf(
+                    "width" to (m.widthPixels / m.density),
+                    "height" to (m.heightPixels / m.density),
+                    "scale" to m.density,
+                )
+        }
+    }
+
+    @JvmStatic
+    fun snapshot(): Map<String, Any?> {
+        val out =
+            mutableMapOf<String, Any?>(
+                "os" to "android",
+                "osVersion" to Build.VERSION.RELEASE,
+                // The hardware identifier, not a marketing name.
+                // Mapping it would need a table that goes stale with
+                // every launch; the dashboard does that lookup
+                // server-side where it can be updated without a client
+                // release.
+                "model" to "${Build.MANUFACTURER} ${Build.MODEL}",
+            )
+        synchronized(lock) { screen }?.let { out["screen"] = it }
+        return out
+    }
+
+    internal fun resetForTests() {
+        synchronized(lock) { screen = null }
+    }
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriFirebaseMessagingService.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriFirebaseMessagingService.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 // v2.10 — FCM message routing service.
 //
 // Manifest-registered in `AndroidManifest.xml`. Firebase's manifest

package/android/src/main/{java → java-core}/com/sentori/SentoriForegroundActivity.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriForegroundActivity.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.app.Activity

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

@@ -0,0 +1,101 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriIdentity.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.security.MessageDigest
+
+/**
+ * Turns a raw identity into the key that travels on the wire.
+ *
+ * Every event carries `userKey`, and a registered device carries the
+ * same one — that join is what lets an issue reach the people it
+ * happened to. The raw value never leaves the device; only this hash
+ * does.
+ *
+ * Three implementations now compute it: TypeScript in
+ * `sdk/core/src/identity.ts`, Swift, and this. They must agree byte
+ * for byte. If they drift, a device stops matching the events from
+ * the same person: the push reaches nobody and nothing reports it,
+ * which is precisely why a second implementation is a bad idea unless
+ * something is holding the three together.
+ *
+ * That something is `sdk/native/fixtures/identity-vectors.json`,
+ * generated by the TypeScript module and asserted by both native
+ * suites.
+ *
+ * The client hash is unsalted. The server layers its own per-scope
+ * salt before storing a fingerprint; several comments in this
+ * codebase call the client value "salted", and they are wrong.
+ */
+object SentoriIdentity {
+
+    /**
+     * SHA-256 of the normalised value, lowercase hex. `null` for an
+     * empty or whitespace-only input — no key beats a meaningless
+     * one, and the caller treats absent as "broadcast only".
+     */
+    @JvmStatic
+    fun hash(keyType: String, value: String?): String? {
+        if (value == null) return null
+        val normalised = normalise(keyType, value)
+        if (normalised.isEmpty()) return null
+        val digest = MessageDigest.getInstance("SHA-256")
+            .digest(normalised.toByteArray(Charsets.UTF_8))
+        val out = StringBuilder(64)
+        for (b in digest) {
+            val v = b.toInt() and 0xff
+            out.append(HEX[v ushr 4]).append(HEX[v and 0x0f])
+        }
+        return out.toString()
+    }
+
+    /**
+     * The key for a user, matching `scope.ts`: the id if there is one,
+     * otherwise the email. Not both — one device, one key.
+     */
+    @JvmStatic
+    fun userKey(id: String?, email: String?): String? =
+        hash("id", id) ?: hash("email", email)
+
+    /**
+     * Well-known normalisations, mirroring `normalise` in
+     * `identity.ts`. A type this does not know about gets a plain
+     * trim, which is that function's `default` branch.
+     */
+    /**
+     * What the other two implementations strip.
+     *
+     * Kotlin's `trim()` uses `Character.isWhitespace`, which counts
+     * neither U+00A0 (no-break space) nor U+FEFF (byte-order mark).
+     * ECMAScript's `WhiteSpace` production counts both, so JavaScript
+     * strips them. Swift's `.whitespacesAndNewlines` counts the first
+     * and not the second, so it needed a fix of its own.
+     *
+     * Three languages, three definitions of blank. A value pasted from
+     * a web page routinely carries these, and any of the defaults
+     * would have made one device hash differently from its own events
+     * — for one user, silently, on the path nobody watches.
+     *
+     * Caught by the shared vectors before it shipped, which is what
+     * they are for.
+     */
+    private fun String.trimLikeTheOthers(): String =
+        trim { it.isWhitespace() || it == '\u00a0' || it == '\ufeff' }
+
+    @JvmStatic
+    internal fun normalise(keyType: String, raw: String): String = when (keyType) {
+        "email", "username" -> raw.trimLikeTheOthers().lowercase()
+        // Everything that is not `+` or an ASCII digit goes, so
+        // "+81 (90) 1234-5678" and "+819012345678" agree. Deliberately
+        // not E.164 validation — that is the host's business; this
+        // only removes formatting noise.
+        "phone" -> raw.filter { it == '+' || it in '0'..'9' }
+        // OAuth subject claims are opaque. Touching them would change
+        // an identifier the provider defined.
+        "googleSub", "appleSub", "metaSub" -> raw
+        else -> raw.trimLikeTheOthers()
+    }
+
+    private val HEX = "0123456789abcdef".toCharArray()
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriMobileVitals.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriMobileVitals.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.os.Process

package/android/src/main/{java → java-core}/com/sentori/SentoriNativeExceptionBridge.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriNativeExceptionBridge.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import java.util.concurrent.ConcurrentLinkedDeque

package/android/src/main/{java → java-core}/com/sentori/SentoriNativeSignals.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriNativeSignals.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 /**