@keepsnappy/react-native 0.0.0-stage → 0.1.0-alpha.12

package/js/sdk/cpuprof.ts

@@ -0,0 +1,133 @@
+// Hermes sampling profiler around measured windows. Sampling starts when the
+// first window opens. Outside a run it stops when the last open window ends, so
+// overlapping windows (a press and the screen it opens) share one span and one
+// file. Inside a run it samples on until `flush=1` and writes one file there.
+// The file is a DevTools .cpuprofile (nodes/samples/timeDeltas) written by the
+// native module into Documents/perf-lab.
+
+export interface CpuProfileNative {
+  cpuProfileStart(hz: number): boolean;
+  cpuProfileStop(): boolean;
+  cpuProfileDump(fileName: string): Record<string, unknown> | null;
+}
+
+export interface CpuSpan {
+  span: number;
+  windows: number[];
+  startedAt: number;
+  started: boolean;
+}
+
+export interface CpuSpanResult {
+  span: number;
+  windows: number[];
+  hz: number;
+  started: boolean;
+  // Sampling goes on; the file is written at flush (or the next dump()).
+  deferred: boolean;
+  fileName: string | null;
+  stopMs: number;
+  dumpMs: number;
+  file: Record<string, unknown> | null;
+  error: string | null;
+}
+
+// `processId` makes file names unique across launches. `deferDump` is true while
+// the process belongs to a run that ends with `flush=1`: then a span is never
+// stopped or dumped at window end (the dump is synchronous on the JS thread and
+// could land inside the next window); it keeps sampling until dump() at flush.
+export const createCpuProfiler = (deps: {
+  native: () => CpuProfileNative | null;
+  now: () => number;
+  processId: string;
+  deferDump: () => boolean;
+}) => {
+  let span: CpuSpan | null = null;
+  let nextSpan = 1;
+  let hz = 250;
+  let enabled = false;
+
+  const configure = (on: boolean, frequency?: number) => {
+    enabled = on;
+    if (frequency !== undefined && Number.isFinite(frequency) && frequency > 0) {
+      hz = Math.min(10000, Math.max(10, Math.round(frequency)));
+    }
+  };
+
+  const fileNameOf = (current: CpuSpan) =>
+    `cpu-${deps.processId}-${current.span}.cpuprofile`;
+
+  const windowOpened = (windowId: number) => {
+    if (!enabled) {
+      return null;
+    }
+    if (span === null) {
+      let started = false;
+      try {
+        started = deps.native()?.cpuProfileStart(hz) ?? false;
+      } catch {
+        started = false;
+      }
+      span = { span: nextSpan++, windows: [], startedAt: deps.now(), started };
+    }
+    span.windows.push(windowId);
+    return span.span;
+  };
+
+  const resultOf = (current: CpuSpan, deferred: boolean): CpuSpanResult => ({
+    span: current.span,
+    windows: [...current.windows],
+    hz,
+    started: current.started,
+    deferred,
+    fileName: current.started ? fileNameOf(current) : null,
+    stopMs: 0,
+    dumpMs: 0,
+    file: null,
+    error: current.started ? null : 'not started',
+  });
+
+  // Stops the running span and writes its file.
+  const dump = (): CpuSpanResult | null => {
+    if (span === null) {
+      return null;
+    }
+    const done = span;
+    span = null;
+    const result = resultOf(done, false);
+    if (!done.started) {
+      return result;
+    }
+    const native = deps.native();
+    try {
+      const t0 = deps.now();
+      native?.cpuProfileStop();
+      const t1 = deps.now();
+      result.file = native?.cpuProfileDump(fileNameOf(done)) ?? null;
+      result.stopMs = t1 - t0;
+      result.dumpMs = deps.now() - t1;
+    } catch (error) {
+      result.error = String(error);
+    }
+    return result;
+  };
+
+  // Called when a window ends; `stillOpen` is the number of windows left.
+  const windowClosed = (stillOpen: number): CpuSpanResult | null => {
+    if (span === null || stillOpen > 0) {
+      return null;
+    }
+    if (deps.deferDump()) {
+      return resultOf(span, true);
+    }
+    return dump();
+  };
+
+  return {
+    configure,
+    windowOpened,
+    windowClosed,
+    dump,
+    status: () => ({ enabled, hz, open: span !== null }),
+  };
+};

package/js/sdk/dormant.ts

@@ -0,0 +1,77 @@
+// A dormant build that was not activated: the only thing installed is the link
+// wrapper, so an activation link can reach the SDK. Its effect starts with the
+// next launch. Nothing else runs: no React hook, no fetch/XHR wrap, no
+// listener besides Linking, no timer, no log line, no push.
+
+import {
+  createActivationStore,
+  type Decision,
+  queryOf,
+} from './activation';
+import { installLinks, linkPatchStatus } from './links';
+
+interface DormantNative {
+  osLog?: (message: string) => void;
+}
+
+interface DormantGlobal {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown;
+  __PERFLAB_HOOK__?: { state?: { mode?: string; listener?: unknown } };
+  __PERF_LAB__?: unknown;
+  expo?: { modules?: Record<string, unknown> };
+}
+
+const g = globalThis as unknown as DormantGlobal;
+
+const NET_MARK = '__perflabNet';
+
+const marked = (value: unknown) =>
+  (typeof value === 'function' || (typeof value === 'object' && value !== null)) &&
+  Object.prototype.hasOwnProperty.call(value, NET_MARK);
+
+// Reads the global's descriptor, not its value: fetch and XMLHttpRequest are
+// lazy getters in React Native and the check must not evaluate them.
+const globalWrapped = (name: string) => {
+  const descriptor = Object.getOwnPropertyDescriptor(g, name);
+  if (!descriptor) {
+    return false;
+  }
+  return descriptor.get ? marked(descriptor.get) : marked(descriptor.value);
+};
+
+const xhrPatched = () => {
+  const descriptor = Object.getOwnPropertyDescriptor(g, 'XMLHttpRequest');
+  if (!descriptor || descriptor.get) {
+    return false;
+  }
+  const proto = (descriptor.value as { prototype?: unknown } | undefined)?.prototype;
+  return marked(proto);
+};
+
+// The checks behind `dump=1` in a dormant process (S8 invariants).
+export const dormantReport = (decision: Decision) => ({
+  mode: 'dormant',
+  buildMode: decision.mode,
+  read: decision.read,
+  reactHook: typeof g.__REACT_DEVTOOLS_GLOBAL_HOOK__,
+  perflabHook: g.__PERFLAB_HOOK__ ? (g.__PERFLAB_HOOK__.state?.mode ?? 'present') : 'absent',
+  sdkGlobal: g.__PERF_LAB__ !== undefined,
+  fetchWrapped: globalWrapped('fetch'),
+  xhrGetterWrapped: globalWrapped('XMLHttpRequest'),
+  xhrPatched: xhrPatched(),
+  links: linkPatchStatus(),
+});
+
+export const startDormant = (decision: Decision) => {
+  const store = createActivationStore(decision.record);
+  installLinks(url => {
+    const params = queryOf(url);
+    store.apply(params);
+    if (params.dump === '1') {
+      // Asked for: one os_log line (iOS) / logcat line (Android), no log file.
+      const native = g.expo?.modules?.PerfLab as DormantNative | undefined;
+      const report = { ...dormantReport(decision), activation: store.stats() };
+      native?.osLog?.(`PERF_LAB dormant ${JSON.stringify(report)}`);
+    }
+  });
+};

package/js/sdk/env.d.ts

@@ -0,0 +1,2 @@
+// Inlined by babel-preset-expo at build time.
+declare const process: { env: Record<string, string | undefined> };