@keepsnappy/react-native 0.1.0-alpha.12 → 0.1.0-alpha.14

package/js/sdk/push-install.ts

@@ -80,7 +80,7 @@ interface SpoolNative {
 const nativeArtifacts = (): ArtifactUploadNative | null => {
   const native = (
     globalThis as unknown as { expo?: { modules?: Record<string, unknown> } }
-  ).expo?.modules?.PerfLab as Partial<ArtifactUploadNative> | undefined;
+  ).expo?.modules?.KeepSnappy as Partial<ArtifactUploadNative> | undefined;
   if (!native || typeof native.artifactUpload !== 'function') {
     return null;
   }
@@ -88,12 +88,12 @@ const nativeArtifacts = (): ArtifactUploadNative | null => {
   return { artifactUpload: (...args) => artifactUpload.apply(native, args) };
 };
 
-// The journal file next to the log (perf-lab/push-spool.jsonl). Without these
+// The journal file next to the log (keepsnappy/push-spool.jsonl). Without these
 // native functions (an older binary) the queue is memory-only, as before.
 const nativeSpool = (): PushSpool | null => {
   const native = (
     globalThis as unknown as { expo?: { modules?: Record<string, unknown> } }
-  ).expo?.modules?.PerfLab as SpoolNative | undefined;
+  ).expo?.modules?.KeepSnappy as SpoolNative | undefined;
   if (
     !native ||
     typeof native.spoolRead !== 'function' ||

package/js/sdk/push.ts

@@ -95,9 +95,13 @@ export interface ClockSample {
 
 const MAX_CLOCK_SAMPLES = 16;
 
-const serverClock = async (res: { json?: () => Promise<unknown> }) => {
+// `bound` rejects when the request's time is up: a native fetch resolves at the headers, and its body can stall with the
+// abort signal ignored.
+const serverClock = async (res: { json?: () => Promise<unknown> }, bound: Promise<never>) => {
   try {
-    const body = (await res.json?.()) as { clock?: { recv_ms?: unknown; send_ms?: unknown } } | undefined;
+    const body = (await Promise.race([res.json?.(), bound])) as
+      | { clock?: { recv_ms?: unknown; send_ms?: unknown } }
+      | undefined;
     const t1 = body?.clock?.recv_ms;
     const t2 = body?.clock?.send_ms;
     return typeof t1 === 'number' && typeof t2 === 'number' ? { t1, t2 } : null;
@@ -240,6 +244,9 @@ export const createPushClient = (deps: PushDeps) => {
   const endpoint = `${deps.url.replace(/\/+$/, '')}/v1/windows`;
   // Set by flushAll: the time (deps.now) every request of that flush must be over by.
   let flushLimit: number | null = null;
+  // Batches of a run (with a token) the ingest refused for good: their lines are gone, so the run lacks data.
+  let refusedRunBatches = 0;
+  let lastRefusedStatus = 0;
   // Rejects after `ms`; a hard bound for a fetch that ignores its abort signal.
   const timeoutAfter = (ms: number) => {
     let handle: unknown;
@@ -603,7 +610,12 @@ export const createPushClient = (deps: PushDeps) => {
     sending = true;
     try {
       if (!device) {
-        device = await deps.getDevice();
+        const bound = timeoutAfter(flushLimit !== null ? Math.max(1, Math.min(timeoutMs, flushLimit - deps.now())) : timeoutMs);
+        try {
+          device = await Promise.race([deps.getDevice(), bound.promise]);
+        } finally {
+          bound.clear();
+        }
       }
       if (!batch.id) {
         // Names exactly these lines (process, first and last sequence, count),
@@ -630,10 +642,10 @@ export const createPushClient = (deps: PushDeps) => {
       });
       const headers: Record<string, string> = {
         'content-type': 'application/json',
-        'x-perflab-key': deps.key,
+        'x-keepsnappy-key': deps.key,
       };
       if (runToken) {
-        headers['x-perflab-run-token'] = runToken;
+        headers['x-keepsnappy-run-token'] = runToken;
       }
       const budget = flushLimit !== null ? Math.max(1, Math.min(timeoutMs, flushLimit - deps.now())) : timeoutMs;
       const controller =
@@ -641,7 +653,8 @@ export const createPushClient = (deps: PushDeps) => {
       const abort = controller
         ? deps.setTimer(() => controller.abort(), budget)
         : null;
-      const hard = flushLimit !== null ? timeoutAfter(budget) : null;
+      // Every request, idle or flush: a flush link waits for an idle send still in flight.
+      const hard = timeoutAfter(budget);
       let status = 0;
       try {
         const t0 = deps.now();
@@ -651,16 +664,16 @@ export const createPushClient = (deps: PushDeps) => {
           body,
           ...(controller ? { signal: controller.signal } : {}),
         });
-        const res = hard ? await Promise.race([pending, hard.promise]) : await pending;
+        const res = await Promise.race([pending, hard.promise]);
         const t3 = deps.now();
         status = res.status;
+        // A fresh batch (202) stored the samples it carried, whether or not its body arrives; a duplicate's go again.
+        if (status === 202) {
+          dropClock(reported);
+        }
         if (runToken && (status === 200 || status === 202)) {
-          const server = await serverClock(res);
+          const server = await serverClock(res, hard.promise);
           if (server) {
-            // Stored only by a fresh batch; a duplicate's samples go again.
-            if (status === 202) {
-              dropClock(reported);
-            }
             keepClock(runToken, { t0, ...server, t3 });
           }
         }
@@ -668,7 +681,7 @@ export const createPushClient = (deps: PushDeps) => {
         if (abort !== null) {
           deps.clearTimer(abort);
         }
-        hard?.clear();
+        hard.clear();
       }
       stats.lastStatus = status;
       if (status === 200 || status === 202) {
@@ -685,6 +698,10 @@ export const createPushClient = (deps: PushDeps) => {
       } else if (isPermanent(status)) {
         stats.batchesRejected++;
         stats.lastError = `rejected ${status}, batch ${batch.id} dropped`;
+        if (batch.token) {
+          refusedRunBatches++;
+          lastRefusedStatus = status;
+        }
         retryBatch = null;
         retryAt = null;
         attempts = 0;
@@ -762,11 +779,23 @@ export const createPushClient = (deps: PushDeps) => {
     resume();
     const sentBefore = stats.batchesSent;
     const linesBefore = stats.linesSent;
+    const refusedBefore = refusedRunBatches;
     let failures = 0;
     flushLimit = deadline;
     try {
       if (inflight) {
-        await inflight;
+        if (deadline === null) {
+          await inflight;
+        } else {
+          const bound = timeoutAfter(Math.max(0, deadline - deps.now()));
+          try {
+            await Promise.race([inflight, bound.promise]);
+          } catch {
+            // the deadline passed first; the loop below starts nothing more
+          } finally {
+            bound.clear();
+          }
+        }
       }
       while (
         (queue.length > 0 || retryBatch) &&
@@ -786,15 +815,21 @@ export const createPushClient = (deps: PushDeps) => {
           }
         }
       }
-      const ok = queue.length === 0 && !retryBatch;
-      if (ok) {
+      const sentAll = queue.length === 0 && !retryBatch;
+      if (sentAll) {
         await sendClock(deadline);
       }
+      const refused = refusedRunBatches - refusedBefore;
+      const ok = sentAll && refused === 0;
       return {
         ok,
         batches: stats.batchesSent - sentBefore,
         lines: stats.linesSent - linesBefore,
-        error: ok ? null : (stats.lastError ?? 'flush deadline'),
+        error: ok
+          ? null
+          : !sentAll
+            ? (stats.lastError ?? 'flush deadline')
+            : `rejected ${lastRefusedStatus}: ${refused} ${refused === 1 ? 'batch' : 'batches'} of the run dropped`,
       };
     } finally {
       flushLimit = null;

package/js/sdk/sampler.ts

@@ -84,7 +84,7 @@ export const SAMPLER_MS_MIN = 250;
 export const SAMPLER_MS_MAX = 60_000;
 // Background interval between native samples. 4 s: Arek 2026-10-16 (followups, RULING ~09:00); windows get their own
 // samples at open and close, so the background ones only serve peak memory in long windows and the heat trend.
-// The native samplers keep the same number as their unconfigured fallback (PerfLabSampler.swift / .kt).
+// The native samplers keep the same number as their unconfigured fallback (KeepSnappySampler.swift / .kt).
 export const SAMPLER_MS_DEFAULT = 4000;
 
 export const parseSamplerMode = (

package/js/zustand-vanilla.js

@@ -1,4 +1,4 @@
-// zustand/vanilla in a PerfLab bundle. withKeepSnappy (metro.js) resolves every
+// zustand/vanilla in a KeepSnappy bundle. withKeepSnappy (metro.js) resolves every
 // `zustand/vanilla` request to this module (zustand 5's index, react and
 // traditional entries all load it by that name), and the name below to the real
 // one. Each store's setState goes through the cause tracker's store writer
@@ -10,7 +10,7 @@ var real = require('@keepsnappy/react-native/zustand/vanilla');
 
 var wrap = function (createState) {
   return function (set, get, api) {
-    var stores = globalThis.__PERFLAB_STORES__;
+    var stores = globalThis.__KEEPSNAPPY_STORES__;
     if (!stores) {
       return createState(set, get, api);
     }

package/metro.js

@@ -195,6 +195,8 @@ function withKeepSnappy(input) {
     );
   }
 
+  process.env.KEEPSNAPPY_SDK_VERSION = require('./js/build-version.js').sdkBuildVersion();
+
   // Transform workers are forked after the config loads and inherit this env.
   process.env[ENV_UPSTREAM] = upstream;
   process.env[ENV_ENTRY] = entry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keepsnappy/react-native",
-  "version": "0.1.0-alpha.12",
+  "version": "0.1.0-alpha.14",
   "description": "KeepSnappy in-app SDK for React Native / Expo: zero-code measurement windows, React commit hook, native signposts and log file",
   "license": "UNLICENSED",
   "repository": {