@goliapkg/sentori-react-native 0.9.1 → 0.9.3

package/src/long-task-monitor.ts

@@ -0,0 +1,99 @@
+// v0.9.6 #4 — JS thread long-task monitor.
+//
+// What it does: a setInterval(50ms) tick checks how much wall-clock
+// passed vs the requested interval. Excess = the JS thread was busy
+// doing something else for at least that much. When the excess
+// crosses 200ms (a "long task" per Chrome's PerformanceObserver
+// threshold) we emit a `sentori.longtask` span so the dashboard's
+// trace waterfall shows where the JS thread stalled.
+//
+// What it does NOT do: capture the stack DURING the long task. JS
+// is single-threaded — by the time our tick runs, the busy code is
+// already gone. The span carries the duration + nearest navigation
+// context (via active span) so triage still has a route to blame.
+//
+// Why this and not a real Hermes sampler: Hermes ships a sampling
+// profiler but accessing it from JS requires RN-internal bridges
+// that vary per RN minor. We could swizzle / vendor headers but
+// that's an Insight-build-config burden. The long-task monitor
+// gets ~80% of the practical value (find slow renders, expensive
+// reducers, accidental sync work in render path) with zero native
+// code + zero RN-version sensitivity.
+//
+// Pairs naturally with +S4 (pre-crash sentinel, RAF frame budget,
+// fires at the slow-frame threshold) — long-task monitor fires
+// further down the slowness scale.
+
+import { startSpan } from '@goliapkg/sentori-core';
+
+const TICK_INTERVAL_MS = 50;
+const LONGTASK_THRESHOLD_MS = 200; // > 200ms blocking = a longtask
+const MAX_EMITS_PER_MIN = 60;
+
+let _timer: ReturnType<typeof setInterval> | null = null;
+let _lastTick = 0;
+let _emitWindowStart = 0;
+let _emitsThisWindow = 0;
+
+export type LongTaskMonitorOptions = {
+  enabled: boolean;
+  /** Threshold ms above which a tick lag becomes a longtask span.
+   *  Default 200ms. Lower → noisier. */
+  thresholdMs?: number;
+};
+
+export function startLongTaskMonitor(opts: LongTaskMonitorOptions): void {
+  if (_timer !== null) return;
+  if (!opts.enabled) return;
+  const threshold = opts.thresholdMs ?? LONGTASK_THRESHOLD_MS;
+  _lastTick = Date.now();
+  _emitWindowStart = _lastTick;
+  _emitsThisWindow = 0;
+  _timer = setInterval(() => {
+    tick(threshold);
+  }, TICK_INTERVAL_MS);
+  (_timer as unknown as { unref?: () => void }).unref?.();
+}
+
+export function stopLongTaskMonitor(): void {
+  if (_timer !== null) {
+    clearInterval(_timer);
+    _timer = null;
+  }
+}
+
+function tick(threshold: number): void {
+  const now = Date.now();
+  const elapsed = now - _lastTick;
+  _lastTick = now;
+  const lag = elapsed - TICK_INTERVAL_MS;
+  if (lag <= threshold) return;
+
+  // Rate-limit emits: at most MAX_EMITS_PER_MIN per minute so a
+  // pathological scroll-block-storm doesn't generate 1000 spans.
+  if (now - _emitWindowStart >= 60_000) {
+    _emitWindowStart = now;
+    _emitsThisWindow = 0;
+  }
+  if (_emitsThisWindow >= MAX_EMITS_PER_MIN) return;
+  _emitsThisWindow += 1;
+
+  const span = startSpan('sentori.longtask', {
+    name: 'js.longtask',
+    startNowMs: now - lag,
+    tags: {
+      'profile.kind': 'longtask',
+      'profile.duration_ms': String(Math.round(lag)),
+      'profile.tick_interval_ms': String(TICK_INTERVAL_MS),
+    },
+  });
+  span.finish({ endNowMs: now, status: 'ok' });
+}
+
+/** Test-only. */
+export function __resetLongTaskMonitorForTests(): void {
+  stopLongTaskMonitor();
+  _lastTick = 0;
+  _emitWindowStart = 0;
+  _emitsThisWindow = 0;
+}

package/src/replay.ts

@@ -0,0 +1,123 @@
+// v0.9.6 #2 — wireframe Session Replay (SDK side).
+//
+// 60-slot ring buffer of native-captured wireframe snapshots. Each
+// tick calls into `SentoriReplayCapture.captureWireframe(maskIds)`
+// which walks the iOS UIView / Android View hierarchy and returns
+// one JSON string per snapshot. captureException flushes the ring
+// as a `replay` attachment (NDJSON: one snapshot per line).
+//
+// Why wireframe and not raster:
+//   • Storage: 80 nodes × ~80 bytes ≈ 6 KB per snapshot vs ~50 KB
+//     for a downsampled JPEG. 60-slot ring ≈ 400 KB raw / ~80 KB
+//     gzipped — fits comfortably in the 500 KB attachment cap.
+//   • Privacy: no pixels means no accidental PII leaks; mask
+//     registry decides what text to replace with "***".
+//   • Replay fidelity: less faithful to pixels but enough to see
+//     which screen the user was on and what was on it. Dashboard
+//     player renders SVG rects — denser-looking than a 1 Hz
+//     screenshot strip.
+
+import { startSpan } from '@goliapkg/sentori-core';
+
+import { getRegisteredMaskQuery } from './mask';
+import { isNativeModuleLinked } from './native-loader';
+
+const TICK_INTERVAL_MS = 1000;
+const RING_SIZE = 60;
+
+let _ring: string[] = [];
+let _timer: ReturnType<typeof setInterval> | null = null;
+let _running = false;
+
+export type ReplayOptions = {
+  mode?: 'off' | 'wireframe';
+  /** Ticks per second. Default 1. */
+  hz?: number;
+};
+
+export function startReplay(opts: ReplayOptions): void {
+  if (_running) return;
+  if (opts.mode !== 'wireframe') return;
+  // Native replay needs the Sentori native module linked. Defensive
+  // — same pattern as other native peers — for Expo Go / unlinked
+  // builds.
+  if (!isNativeModuleLinked('Sentori') && !isNativeModuleLinked('SentoriModule')) {
+    // Falls back silently. Replay rings stay empty; captureException
+    // simply doesn't attach a replay.
+    return;
+  }
+  _running = true;
+  const period = Math.max(250, Math.floor(1000 / (opts.hz ?? 1)));
+  _timer = setInterval(() => {
+    captureTick();
+  }, period);
+  (_timer as unknown as { unref?: () => void }).unref?.();
+}
+
+export function stopReplay(): void {
+  _running = false;
+  if (_timer !== null) {
+    clearInterval(_timer);
+    _timer = null;
+  }
+}
+
+function captureTick(): void {
+  if (!_running) return;
+  const tickSpan = startSpan('sentori.replay.tick', { name: 'tick' });
+  try {
+    const maskIds = readMaskIds();
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const nativeMod = loadNativeReplay();
+    const snapshot = nativeMod?.captureWireframe?.(maskIds);
+    if (typeof snapshot === 'string' && snapshot.length > 0) {
+      _ring.push(snapshot);
+      while (_ring.length > RING_SIZE) _ring.shift();
+    }
+    tickSpan.finish({ status: 'ok' });
+  } catch (e) {
+    if (e instanceof Error) tickSpan.setTag('error.message', e.message);
+    tickSpan.finish({ status: 'error' });
+  }
+}
+
+function readMaskIds(): string[] {
+  const q = getRegisteredMaskQuery();
+  if (!q) return [];
+  try {
+    return q();
+  } catch {
+    return [];
+  }
+}
+
+type ReplayNativeModule = {
+  captureWireframe?: (maskedIds: string[]) => null | string;
+};
+
+function loadNativeReplay(): ReplayNativeModule | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const core = require('expo-modules-core') as {
+      requireNativeModule: <T>(name: string) => T;
+    };
+    return core.requireNativeModule<ReplayNativeModule>('Sentori');
+  } catch {
+    return null;
+  }
+}
+
+/** Drain the ring as NDJSON (one snapshot per line). Empty string
+ *  when the ring is empty. Also clears the ring so the next session's
+ *  replay starts fresh. */
+export function drainReplay(): string {
+  if (_ring.length === 0) return '';
+  const out = _ring.join('\n');
+  _ring = [];
+  return out;
+}
+
+export function __resetReplayForTests(): void {
+  stopReplay();
+  _ring = [];
+}

package/src/transport.ts

@@ -1,6 +1,7 @@
 import { drainSpans } from '@goliapkg/sentori-core';
 
 import { getConfig } from './config';
+import { isLiveMode } from './control-channel';
 import { isAnyNativeModuleLinked } from './native-loader';
 import type { Event } from './types';
 
@@ -25,6 +26,13 @@ const SDK_VERSION = '0.0.0';
 
 export const enqueue = (event: Event): void => {
   _queue.push(event);
+  // v1.1 +S7 升级 — when the dashboard has armed live-debug for the
+  // current user, flush immediately instead of waiting for the 5 s
+  // batch interval. Dashboard sees each event with sub-second latency.
+  if (isLiveMode()) {
+    void flush();
+    return;
+  }
   if (_queue.length >= BATCH_SIZE) {
     void flush();
   } else if (!_flushTimer) {