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

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

@@ -54,7 +54,7 @@ export const ARTIFACT_REQUEST_TIMEOUT_MS = 15_000;
 export const ARTIFACT_PUT_TIMEOUT_MS = 60_000;
 // One deadline per flush, started at the flush link (core.ts flushOnce) and shared by the lines push, the clock
 // report and the artifact upload (this file's ARTIFACT_UPLOAD_DEADLINE_MS is that deadline). The end report gets its
-// own request timeout after it, so `perflab.flushed` is raised at most ARTIFACT_FLUSH_WORST_CASE_MS after the link.
+// own request timeout after it, so `keepsnappy.flushed` is raised at most ARTIFACT_FLUSH_WORST_CASE_MS after the link.
 // The e2e driver's wait for it is derived from this.
 export const ARTIFACT_FLUSH_WORST_CASE_MS = ARTIFACT_UPLOAD_DEADLINE_MS + ARTIFACT_REQUEST_TIMEOUT_MS;
 // Longest pause between two attempts at one file. SDK choice: half the Retry-After cap below, so a failing file never
@@ -324,8 +324,8 @@ export const createArtifactUploader = (deps: ArtifactUploaderDeps) => {
           method: 'POST',
           headers: {
             'content-type': 'application/json',
-            'x-perflab-key': deps.key,
-            'x-perflab-run-token': token,
+            'x-keepsnappy-key': deps.key,
+            'x-keepsnappy-run-token': token,
           },
           body: JSON.stringify(body),
           ...(controller ? { signal: controller.signal } : {}),
@@ -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/boot.ts

@@ -1,13 +1,13 @@
-// perf-lab SDK entry. withKeepSnappy (metro.js) adds this module to the graph and
+// keepsnappy SDK entry. withKeepSnappy (metro.js) adds this module to the graph and
 // runs it after InitializeCore, before the app's entry module. The React hook
 // itself was installed earlier by hook.polyfill.js (unless dormant).
 //
 // The measuring SDK (active.ts and everything it imports) is required only when
 // this process measures, so a dormant process never evaluates it.
 
-import { type Decision, PERF_LAB_ENABLED, resolveDecision } from './activation';
+import { type Decision, KEEPSNAPPY_ENABLED, resolveDecision } from './activation';
 
-if (PERF_LAB_ENABLED) {
+if (KEEPSNAPPY_ENABLED) {
   try {
     const decision: Decision = resolveDecision();
     if (decision.active) {
@@ -16,6 +16,6 @@ if (PERF_LAB_ENABLED) {
       (require('./dormant') as typeof import('./dormant')).startDormant(decision);
     }
   } catch (error) {
-    globalThis.console.log(`PERF_LAB boot failed ${String(error)}`);
+    globalThis.console.log(`KEEPSNAPPY boot failed ${String(error)}`);
   }
 }

package/js/sdk/causes.ts

@@ -743,7 +743,7 @@ const wrapDeviceEmitter = (emitter: { emit: AnyFn } | undefined) => {
 // Responses of a request run under the cause of the code that sent it.
 const wrapXhr = (proto: Record<string, unknown> | undefined) => {
   if (!proto || typeof proto.send !== 'function') return;
-  const CAUSE = '__perflabCause';
+  const CAUSE = '__keepsnappyCause';
   const send = proto.send as AnyFn;
   proto.send = function (this: Record<string, unknown>, ...args: unknown[]) {
     this[CAUSE] = captured();
@@ -880,7 +880,7 @@ export const installCauses = (deps: CauseDeps = {}) => {
       | { addListener?: (type: string, fn: (event: RawEvent) => void) => unknown }
       | undefined;
     raw?.addListener?.('*', onRawEvent);
-    g.__PERFLAB_STORES__ = { writer: storeWriter };
+    g.__KEEPSNAPPY_STORES__ = { writer: storeWriter };
     causeStats.installed = true;
   } catch {
     causeStats.errors++;