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

package/android/src/main/java/expo/modules/keepsnappy/KeepSnappyModule.kt

@@ -39,6 +39,9 @@ private const val FLUSH_ELEMENT_TAG = "keepsnappy.flushed.view"
 private const val FLUSH_ELEMENT_DP = 8
 // Alpha 1 of 255: drawn, so it counts as visible, but no pixel changes on screen.
 private const val FLUSH_ELEMENT_BACKGROUND = 0x01000000
+// No foreground activity or window yet (a relaunch, a link mid-transition): tried again this often, this far apart.
+private const val FLUSH_ELEMENT_RETRIES = 3
+private const val FLUSH_ELEMENT_RETRY_MS = 1000L
 
 
 // logcat drops the tail of a line past ~4 KB, so long payloads go out in chunks.
@@ -79,7 +82,7 @@ class KeepSnappyModule : Module() {
             // `am broadcast --es n 3` and `--ei n 3` both reach here.
             @Suppress("DEPRECATION")
             val n = intent.extras?.get("n")?.toString()?.toIntOrNull()
-            if (cmd != "gc" || n == null || n < 1) {
+            if ((cmd != "gc" && cmd != "memread") || n == null || n < 1) {
               resultCode = Activity.RESULT_CANCELED
               resultData = "bad command"
               return
@@ -90,7 +93,7 @@ class KeepSnappyModule : Module() {
             pendingCommands[n] = pending
             mainHandler.postDelayed({
               if (pendingCommands.remove(n, pending)) {
-                pending.setResult(Activity.RESULT_CANCELED, "gc:$n timeout", null)
+                pending.setResult(Activity.RESULT_CANCELED, "$cmd:$n timeout", null)
                 pending.finish()
               }
             }, commandDeadlineMs)
@@ -114,19 +117,33 @@ class KeepSnappyModule : Module() {
     }
   }
 
-  private fun showFlushElement(status: String) {
+  private fun showFlushElement(status: String, detail: String, attempt: Int = 0) {
+    fun retry(reason: String) {
+      if (attempt < FLUSH_ELEMENT_RETRIES) {
+        mainHandler.postDelayed({ showFlushElement(status, detail, attempt + 1) }, FLUSH_ELEMENT_RETRY_MS)
+      } else {
+        writeLog("KEEPSNAPPY flush element not shown: $reason after ${attempt + 1} tries ($status)")
+      }
+    }
     val activity = appContext.currentActivity
     if (activity == null) {
-      writeLog("KEEPSNAPPY flush element not shown: no foreground activity ($status)")
+      retry("no foreground activity")
       return
     }
     mainHandler.post {
-      val decor = activity.window?.decorView as? ViewGroup ?: return@post
+      val decor = activity.window?.decorView as? ViewGroup
+      if (decor == null) {
+        retry("no window")
+        return@post
+      }
       decor.findViewWithTag<View>(FLUSH_ELEMENT_TAG)?.let { decor.removeView(it) }
       val view = TextView(activity).apply {
         tag = FLUSH_ELEMENT_TAG
         text = status
         setTextColor(Color.TRANSPARENT)
+        // The SDK's detail (what failed with `error`): UiAutomator2 reads it as the `hint` attribute; iOS has it as the value.
+        hint = detail
+        setHintTextColor(Color.TRANSPARENT)
         // UiAutomator2 drops nodes Android reports as not visible to the user, and a 1 px view in the corner under the system bars was one. Measured on a Galaxy S23 (Android 16): found at 8 dp on the left edge, middle of the screen.
         setBackgroundColor(FLUSH_ELEMENT_BACKGROUND)
         contentDescription = FLUSH_ELEMENT_ID
@@ -380,7 +397,7 @@ class KeepSnappyModule : Module() {
     // like iOS it stays until the next flush replaces it or the process ends. Always logged too.
     Function("flushSignal") { status: String, detail: String ->
       writeLog("KEEPSNAPPY flushed $status $detail")
-      showFlushElement(status)
+      showFlushElement(status, detail)
     }
 
     Function("spoolAppend") { record: String ->
@@ -413,6 +430,30 @@ class KeepSnappyModule : Module() {
       }.get()
     }
 
+    // The profile files a flush has not uploaded yet, with their run tokens: internal storage, like the push journal.
+    Function("artifactsPendingRead") {
+      io.submit<String?> {
+        val file = stateDir(false)?.let { File(it, "artifacts-pending.json") }
+        if (file != null && file.exists()) {
+          try { file.readText() } catch (e: Exception) { null }
+        } else {
+          null
+        }
+      }.get()
+    }
+
+    Function("artifactsPendingWrite") { content: String ->
+      io.submit<Boolean> {
+        val dir = stateDir(true) ?: return@submit false
+        val file = File(dir, "artifacts-pending.json")
+        if (content.isEmpty()) {
+          !file.exists() || file.delete()
+        } else {
+          writeAtomically(file, content)
+        }
+      }.get()
+    }
+
     // System.nanoTime() is CLOCK_MONOTONIC on Android, the same clock as
     // performance.now() in RN and the MONOTONIC snapshot in Perfetto.
     Function("clockSnapshot") {

package/ios/KeepSnappyModule.swift

@@ -139,6 +139,31 @@ public class KeepSnappyModule: Module {
       }
     }
 
+    // The profile files a flush has not uploaded yet, with their run tokens; read by a later process.
+    Function("artifactsPendingRead") { () -> String? in
+      self.logQueue.sync {
+        guard let file = Self.fileIfPresent("artifacts-pending.json") else { return nil }
+        return try? String(contentsOf: file, encoding: .utf8)
+      }
+    }
+
+    Function("artifactsPendingWrite") { (content: String) -> Bool in
+      self.logQueue.sync {
+        guard let dir = Self.outputDir() else { return false }
+        let file = dir.appendingPathComponent("artifacts-pending.json")
+        if content.isEmpty {
+          try? FileManager.default.removeItem(at: file)
+          return true
+        }
+        do {
+          try content.write(to: file, atomically: true, encoding: .utf8)
+          return true
+        } catch {
+          return false
+        }
+      }
+    }
+
     Function("spoolReplace") { (content: String) -> Bool in
       self.logQueue.sync {
         try? self.spoolHandle?.close()
@@ -296,12 +321,26 @@ public class KeepSnappyModule: Module {
   private static let flushSignalTag = 0x9E7F_1A5
   private static let ackSignalTag = 0x9E7F_1A6
 
+  // No window yet (a relaunch, a link mid-transition): tried again this often, this far apart.
+  private static let signalRetries = 3
+  private static let signalRetryNanoseconds: UInt64 = 1_000_000_000
+
   @MainActor
-  private static func showSignal(tag: Int, id: String, label status: String, value detail: String) {
+  private static func showSignal(tag: Int, id: String, label status: String, value detail: String, attempt: Int = 0) {
     let windows = UIApplication.shared.connectedScenes
       .compactMap { $0 as? UIWindowScene }
       .flatMap { $0.windows }
-    guard let window = windows.first(where: { $0.isKeyWindow }) ?? windows.first else { return }
+    guard let window = windows.first(where: { $0.isKeyWindow }) ?? windows.first else {
+      if attempt < signalRetries {
+        Task { @MainActor in
+          try? await Task.sleep(nanoseconds: signalRetryNanoseconds)
+          Self.showSignal(tag: tag, id: id, label: status, value: detail, attempt: attempt + 1)
+        }
+      } else {
+        emit("KEEPSNAPPY \(id) not shown: no window after \(attempt + 1) tries (\(status))")
+      }
+      return
+    }
     window.viewWithTag(tag)?.removeFromSuperview()
     let label = UILabel(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
     label.tag = tag

package/js/babel-transformer.js

@@ -11,8 +11,9 @@ const path = require('path');
 const upstreamPath = (process.env.KEEPSNAPPY_UPSTREAM_BABEL_TRANSFORMER);
 const entryFile = (process.env.KEEPSNAPPY_ENTRY_FILE);
 const bootFile = (process.env.KEEPSNAPPY_BOOT_FILE);
+const sdkVersion = process.env.KEEPSNAPPY_SDK_VERSION;
 
-if (!upstreamPath || !entryFile || !bootFile) {
+if (!upstreamPath || !entryFile || !bootFile || !sdkVersion) {
   throw new Error(
     'KeepSnappy Babel transformer loaded without withKeepSnappy env (KEEPSNAPPY_*)',
   );
@@ -57,7 +58,10 @@ module.exports = {
       return upstream.transform({ ...args, src: bootImport() + args.src });
     }
     if (file.startsWith(packageRoot)) {
-      return upstream.transform({ ...args, src: inlineEnv(args.src) });
+      const src = file === path.join(packageRoot, 'js', 'sdk', 'push-install.ts')
+        ? args.src.replace("require('../../package.json')", JSON.stringify({ version: sdkVersion }))
+        : args.src;
+      return upstream.transform({ ...args, src: inlineEnv(src) });
     }
     return upstream.transform(args);
   },
@@ -66,6 +70,6 @@ module.exports = {
       typeof upstream.getCacheKey === 'function'
         ? upstream.getCacheKey(...args)
         : '';
-    return `${base}$keepsnappy:${entryFile}:${bootFile}:${envSignature()}`;
+    return `${base}$keepsnappy:${entryFile}:${bootFile}:${sdkVersion}:${envSignature()}`;
   },
 };

package/js/build-version.js

@@ -0,0 +1,23 @@
+// Build tooling only: Metro workers receive the identity in their inherited env.
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function sdkBuildVersion() {
+  const packageRoot = path.resolve(__dirname, '..');
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  if (!pkg.private) return pkg.version;
+  const git = args => execFileSync('git', args, { cwd: packageRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+  try {
+    const root = git(['rev-parse', '--show-toplevel']);
+    const release = JSON.parse(fs.readFileSync(path.join(root, 'release.json'), 'utf8')).version;
+    if (typeof release !== 'string' || !release) throw new Error('release.json has no version');
+    const sha = git(['rev-parse', '--short', 'HEAD']);
+    const dirty = git(['status', '--porcelain', '--untracked-files=normal']) ? '.dirty' : '';
+    return `${release}+local.${sha}${dirty}`;
+  } catch (cause) {
+    throw new Error('KeepSnappy: cannot identify this unpublished SDK; build from its Git checkout or use a staged release package', { cause });
+  }
+}
+
+module.exports = { sdkBuildVersion };

package/js/sdk/artifact-pending.ts

@@ -0,0 +1,167 @@
+// Profile files a flush has not uploaded yet, kept in the app's internal storage with their run tokens (next to the push
+// journal), so a later process uploads them: a flush that never finished, a process killed in the middle of the upload.
+// A process's whole list is kept, uploaded files too: the run's flush report counts every file the run made.
+
+import type { ArtifactEntry, ArtifactKind, ArtifactReason, ArtifactState } from './artifacts';
+
+export interface PendingArtifactStore {
+  read(): string | null;
+  // '' removes the record.
+  write(content: string): boolean;
+}
+
+interface SavedEntry {
+  name: string;
+  kind: ArtifactKind;
+  reasons: ArtifactReason[];
+  windows: number[];
+  bytes: number | null;
+  runToken: string | null;
+  state: ArtifactState;
+}
+
+interface SavedGroup {
+  processId: string;
+  // Flushes of later processes that tried this group.
+  tries: number;
+  entries: SavedEntry[];
+}
+
+export interface EarlierArtifacts {
+  processId: string;
+  entries: ArtifactEntry[];
+}
+
+// A file whose upload fails at this many later flushes (missing on disk, refused) stops being tried.
+export const PENDING_ARTIFACT_TRIES = 3;
+
+const owed = (state: ArtifactState) => state === 'pending' || state === 'failed';
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const savedEntry = (value: unknown): SavedEntry | null => {
+  if (!isObject(value) || typeof value.name !== 'string' || typeof value.kind !== 'string' || typeof value.state !== 'string') {
+    return null;
+  }
+  return {
+    name: value.name,
+    kind: value.kind as ArtifactKind,
+    reasons: Array.isArray(value.reasons) ? (value.reasons as ArtifactReason[]) : [],
+    windows: Array.isArray(value.windows) ? (value.windows as number[]) : [],
+    bytes: typeof value.bytes === 'number' ? value.bytes : null,
+    runToken: typeof value.runToken === 'string' ? value.runToken : null,
+    state: value.state as ArtifactState,
+  };
+};
+
+const parse = (raw: string | null): SavedGroup[] => {
+  if (!raw) {
+    return [];
+  }
+  try {
+    const value = JSON.parse(raw) as unknown;
+    if (!isObject(value) || value.v !== 1 || !Array.isArray(value.groups)) {
+      return [];
+    }
+    return value.groups.flatMap(group => {
+      if (!isObject(group) || typeof group.processId !== 'string' || !Array.isArray(group.entries)) {
+        return [];
+      }
+      const entries = group.entries.map(savedEntry).filter((e): e is SavedEntry => e !== null);
+      return [{ processId: group.processId, tries: typeof group.tries === 'number' ? group.tries : 0, entries }];
+    });
+  } catch {
+    return [];
+  }
+};
+
+const toSaved = (entry: ArtifactEntry, token: string | null): SavedEntry => ({
+  name: entry.name,
+  kind: entry.kind,
+  reasons: entry.reasons,
+  windows: entry.windows,
+  bytes: entry.bytes,
+  runToken: entry.runToken !== undefined ? entry.runToken : token,
+  state: entry.state,
+});
+
+const toEntry = (saved: SavedEntry): ArtifactEntry => ({
+  name: saved.name,
+  kind: saved.kind,
+  reasons: saved.reasons,
+  windows: saved.windows,
+  bytes: saved.bytes,
+  state: owed(saved.state) ? 'pending' : saved.state,
+  artifactId: null,
+  gzBytes: null,
+  sha256: null,
+  attempts: 0,
+  error: null,
+  runToken: saved.runToken,
+});
+
+// `store` is looked up at each call: null (an older binary) keeps nothing, as before.
+export const createPendingArtifacts = (store: () => PendingArtifactStore | null, log: (message: string) => void) => {
+  const read = () => {
+    try {
+      return parse(store()?.read() ?? null);
+    } catch (error) {
+      log(`artifacts pending read failed ${String(error)}`);
+      return [];
+    }
+  };
+  const save = (groups: SavedGroup[]) => {
+    const target = store();
+    if (!target) {
+      return;
+    }
+    const kept = groups.filter(group => group.entries.some(entry => owed(entry.state)));
+    try {
+      target.write(kept.length > 0 ? JSON.stringify({ v: 1, groups: kept }) : '');
+    } catch (error) {
+      log(`artifacts pending write failed ${String(error)}`);
+    }
+  };
+
+  return {
+    // This process's files as they stand now; replaces its earlier record.
+    note(processId: string, entries: ArtifactEntry[], token: string | null) {
+      if (!store()) {
+        return;
+      }
+      const groups = read().filter(group => group.processId !== processId);
+      groups.push({ processId, tries: 0, entries: entries.map(entry => toSaved(entry, token)) });
+      save(groups);
+    },
+    // Earlier processes' lists, as entries the uploader takes: what is owed is pending again.
+    earlier(processId: string): EarlierArtifacts[] {
+      return read()
+        .filter(group => group.processId !== processId)
+        .map(group => ({ processId: group.processId, entries: group.entries.map(toEntry) }));
+    },
+    // After those were tried: what is still owed stays, for at most PENDING_ARTIFACT_TRIES flushes.
+    settleEarlier(tried: EarlierArtifacts[]) {
+      const byProcess = new Map(tried.map(group => [group.processId, group]));
+      const groups: SavedGroup[] = [];
+      for (const group of read()) {
+        const done = byProcess.get(group.processId);
+        if (!done) {
+          groups.push(group);
+          continue;
+        }
+        const entries = done.entries.map(entry => toSaved(entry, null));
+        const left = entries.filter(entry => owed(entry.state));
+        // A try is an upload that was attempted and failed; a file the deadline stopped first was not tried.
+        const attempted = done.entries.some(entry => owed(entry.state) && entry.attempts > 0);
+        const tries = attempted ? group.tries + 1 : group.tries;
+        if (left.length > 0 && tries >= PENDING_ARTIFACT_TRIES) {
+          log(`artifacts earlier dropped ${JSON.stringify({ processId: group.processId, tries, files: left.map(entry => entry.name) })}`);
+          continue;
+        }
+        groups.push({ processId: group.processId, tries, entries });
+      }
+      save(groups);
+    },
+  };
+};

package/js/sdk/artifacts.ts

@@ -622,7 +622,8 @@ export const createArtifactUploader = (deps: ArtifactUploaderDeps) => {
       deps.log(`artifacts upload stopped: ${reported}`);
     }
     const summary = summarizeArtifacts(entries, deps.now() - t0, reported);
-    await report(entries, token, 'end', deps.now() + requestTimeoutMs, reported);
+    // At most one request timeout past the flush deadline, however late the upload ran: ARTIFACT_FLUSH_WORST_CASE_MS holds.
+    await report(entries, token, 'end', Math.min(deps.now(), deadline) + requestTimeoutMs, reported);
     return summary;
   };
 

package/js/sdk/core.ts

@@ -32,6 +32,7 @@ import {
   summarizeArtifacts,
   type WrittenFile,
 } from './artifacts';
+import { createPendingArtifacts, type EarlierArtifacts } from './artifact-pending';
 import {
   backgroundSource,
   type Carrier,
@@ -143,7 +144,10 @@ interface KeepSnappyNative extends Partial<CpuProfileNative> {
   samplerRecent(sinceT: number): SamplerRecord[];
   samplerNow(): number;
   flushSignal?(status: string, detail: string): void;
-  // GC before the action: Android finishes the pending command broadcast with this result; iOS shows it on `keepsnappy.ack`.
+  // The list of profile files not uploaded yet, with run tokens: internal storage, read by a later process.
+  artifactsPendingRead?(): string | null;
+  artifactsPendingWrite?(content: string): boolean;
+  // Command answer (`gc:<n> ok`, `memread:<n> ok`): Android finishes the pending command broadcast with this result; iOS shows it on `keepsnappy.ack`.
   commandDone?(n: number, data: string): void;
   /** Android: whether the broadcast of command n still waits for its answer (native finishes it at a deadline). */
   commandPending?(n: number): boolean;
@@ -1617,6 +1621,17 @@ export const setArtifactHandler = (handler: ArtifactHandler | null) => {
 // Entries a window interrupted wait for the next flush of this process.
 let artifactBacklog: ArtifactEntry[] = [];
 
+const pendingArtifacts = createPendingArtifacts(() => {
+  const native = getNative();
+  if (typeof native?.artifactsPendingRead !== 'function' || typeof native.artifactsPendingWrite !== 'function') {
+    return null;
+  }
+  return {
+    read: () => native.artifactsPendingRead!(),
+    write: content => native.artifactsPendingWrite!(content),
+  };
+}, perfLog);
+
 const writeManifest = (entries: ArtifactEntry[], upload: ArtifactUploadSummary | null) => {
   try {
     const manifest = buildManifest({
@@ -1662,11 +1677,39 @@ const sendArtifacts = async (fresh: ArtifactEntry[], deadline: number) => {
     summary = summarizeArtifacts(entries, 0, 'push not configured');
   }
   artifactBacklog = entries.filter(entry => entry.state === 'pending' || entry.state === 'failed');
+  pendingArtifacts.note(PROCESS_ID, entries, runToken);
   writeManifest(entries, summary);
   perfLog(`artifacts ${JSON.stringify(summary)}`);
   return summary;
 };
 
+// After this process's own files: what earlier processes left (a flush that never finished, a kill during the upload), each
+// under its own run token and process id, within the same deadline.
+const sendEarlierArtifacts = async (deadline: number) => {
+  if (!artifactHandler) {
+    return;
+  }
+  const groups: EarlierArtifacts[] = pendingArtifacts.earlier(PROCESS_ID);
+  if (groups.length === 0) {
+    return;
+  }
+  const tried: EarlierArtifacts[] = [];
+  for (const group of groups) {
+    // What does not fit in this flush waits for the next one, with no try counted.
+    if (Date.now() >= deadline) {
+      break;
+    }
+    tried.push(group);
+    try {
+      const summary = await artifactHandler(group.entries, null, group.processId, deadline);
+      perfLog(`artifacts earlier ${JSON.stringify({ processId: group.processId, ...summary })}`);
+    } catch (error) {
+      perfLog(`artifacts earlier failed ${String(error)}`);
+    }
+  }
+  pendingArtifacts.settleEarlier(tried);
+};
+
 // Declared on every window line so the backend can tell windows of this model from older ones (REQ-VER-34).
 // 2: a tap or scroll window runs from its touch to the next touch, the background or the flush; no quiet rule, no `+3s` twin.
 // 3: model 2, and a screen window also ends at the next action, the next screen, the background or the flush; no 3 s cap.
@@ -1997,7 +2040,11 @@ export const setFlushHandler = (handler: FlushHandler | null) => {
 // `flush=1`: end the open windows, send every unsent line, then show the result
 // to the test driver as an accessibility element (iOS: id `keepsnappy.flushed`,
 // label `ok` / `error` / `off`), so a flow can wait for it without network access.
-const flushOnce = async () => {
+// The driver's name for one flush link (`ack=<n>`), echoed at the end of the answer's detail: the answer element stays up
+// until the next one replaces it, so without it a later flush in the same process could read an earlier flush's answer.
+const ACK_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
+
+const flushOnce = async (ack: string | undefined) => {
   // One deadline for the whole flush (lines, clock, artifacts); the end report of the upload comes after it.
   const deadline = Date.now() + ARTIFACT_UPLOAD_DEADLINE_MS;
   endAll('flush');
@@ -2008,6 +2055,8 @@ const flushOnce = async () => {
   } catch (error) {
     perfLog(`flush files failed ${String(error)}`);
   }
+  // Before anything that waits on the network: a flush that never ends, or a process killed now, leaves the list to a later one.
+  pendingArtifacts.note(PROCESS_ID, [...artifactBacklog, ...artifacts], runToken);
   let status = 'off';
   let detail = 'push not configured';
   if (flushHandler) {
@@ -2026,10 +2075,25 @@ const flushOnce = async () => {
     const sent = await sendArtifacts(artifacts, deadline);
     if (sent) {
       detail += ` artifacts=${sent.uploaded}/${sent.total}`;
+      // A profile file of a run that did not reach the API is missing data, whatever kept it back: failed after its tries, left
+      // unsent by the deadline, kept on the device (token refused, no endpoint, no native upload) or refused by the API.
+      const missing = sent.failed + sent.pending + (runToken !== null ? sent.local + sent.rejected : 0);
+      if (status === 'ok' && missing > 0) {
+        status = 'error';
+        detail += ` failed=${sent.failed} pending=${sent.pending} local=${sent.local} rejected=${sent.rejected}`;
+      }
     }
   } catch (error) {
     perfLog(`artifacts failed ${String(error)}`);
   }
+  try {
+    await sendEarlierArtifacts(deadline);
+  } catch (error) {
+    perfLog(`artifacts earlier failed ${String(error)}`);
+  }
+  if (ack !== undefined && ACK_PATTERN.test(ack)) {
+    detail += ` ack=${ack}`;
+  }
   perfLog(`flush ${status} ${detail}`);
   try {
     getNative()?.flushSignal?.(status, detail);
@@ -2041,11 +2105,11 @@ const flushOnce = async () => {
 // A second flush link while one runs (the driver's final flush) waits for it: the flush signal means the
 // uploads of the first are done, so it must not be raised by a flush that has nothing left to send.
 let flushing: Promise<void> | null = null;
-export const flushNow = (): Promise<void> => {
+export const flushNow = (ack?: string): Promise<void> => {
   commandAnswers.clear();
   gcRanSinceFlush = false;
   // The first flush starts at once (it ends the open windows in the same tick as the link).
-  const run = flushing === null ? flushOnce() : flushing.then(flushOnce);
+  const run = flushing === null ? flushOnce(ack) : flushing.then(() => flushOnce(ack));
   const tail: Promise<void> = run
     .catch(() => undefined)
     .then(() => {
@@ -2242,10 +2306,32 @@ export const actionGc = (n: number, tNative?: number): string => {
   }
   // The gc-pre / gc-post records go out now: the backend pairs them with this command by their seq.
   forwardSamples();
+  rememberAnswer(key, answer);
+  answerCommand(n, answer);
+  return answer;
+};
+
+const rememberAnswer = (key: string, answer: string) => {
   commandAnswers.set(key, answer);
   if (commandAnswers.size > COMMAND_ANSWERS_KEPT) {
     commandAnswers.delete(commandAnswers.keys().next().value as string);
   }
+};
+
+// The end GC's manual memory read: the driver's `memread` command, sent with the GC's own n after the GC's answer. One sample, at
+// once (no timer), reason `endgc-read:<n>`, sent with the run's lines before the answer; the answer is the driver's signal that the
+// app may go to the background. Derive reads kept from this record (derivation 23).
+export const endGcRead = (n: number): string => {
+  const key = `${runToken ?? '-'}#read${n}`;
+  const known = commandAnswers.get(key);
+  if (known !== undefined) {
+    answerCommand(n, known);
+    return known;
+  }
+  const record = sample(`endgc-read:${n}`);
+  const answer = `memread:${n} ${record ? 'ok' : 'unavailable'}`;
+  forwardSamples();
+  rememberAnswer(key, answer);
   answerCommand(n, answer);
   return answer;
 };
@@ -2264,7 +2350,7 @@ const syncCommandListener = () => {
       native.addListener?.('keepsnappyCommand', e => {
         // A command native already timed out on is not run: its GC would land in the next step's action.
         if (native.commandPending?.(e.n) === false) {
-          perfLog(`command gc:${e.n} late, skipped`);
+          perfLog(`command ${e.cmd}:${e.n} late, skipped`);
           return;
         }
         handleKeepSnappyCommand(e.cmd, e.n, e.tNative);
@@ -2275,15 +2361,19 @@ const syncCommandListener = () => {
 
 /** A command (`cmd=<name>&n=<n>`), from a link (iOS) or the native receiver (Android); unknown commands are ignored. */
 export const handleKeepSnappyCommand = (cmd: string | undefined, n: number, tNative?: number): boolean => {
-  if (!KEEPSNAPPY_ENABLED || cmd !== 'gc' || !Number.isInteger(n) || n < 1) {
+  if (!KEEPSNAPPY_ENABLED || (cmd !== 'gc' && cmd !== 'memread') || !Number.isInteger(n) || n < 1) {
     return false;
   }
   // Every received command is answered, so the Android receiver is never left pending.
   try {
-    actionGc(n, tNative);
+    if (cmd === 'gc') {
+      actionGc(n, tNative);
+    } else {
+      endGcRead(n);
+    }
   } catch (error) {
-    perfLog(`command gc:${n} failed ${String(error)}`);
-    answerCommand(n, `gc:${n} error`);
+    perfLog(`command ${cmd}:${n} failed ${String(error)}`);
+    answerCommand(n, `${cmd}:${n} error`);
   }
   return true;
 };
@@ -2306,7 +2396,7 @@ export const handleKeepSnappyDeepLink = (url: string) => {
   }
   applySettings(params);
   if (params.flush === '1') {
-    void flushNow();
+    void flushNow(params.ack);
   }
 };
 

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),
@@ -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/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.13",
+  "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": {