@goliapkg/sentori-react-native 0.7.6 → 0.8.1

package/src/index.ts

@@ -9,8 +9,18 @@ import {
   setUser,
 } from './capture';
 import { ErrorBoundary } from './error-boundary';
+import { FeedbackButton, type FeedbackButtonHandle, type FeedbackButtonProps } from './feedback-widget';
+import {
+  clearAllFeatureFlags,
+  clearFeatureFlag,
+  getFeatureFlags,
+  setFeatureFlag,
+} from './feature-flags';
 import { clearMaskQuery, registerMaskQuery } from './mask';
+import { measureFn } from './measure';
+import { startMoment } from '@goliapkg/sentori-core';
 import { flushMetrics, recordMetric } from './metrics';
+import { RageTapCapture } from './rage-tap';
 import {
   endSession,
   markSessionCrashed,
@@ -28,7 +38,15 @@ export const sentori = {
   sendUserFeedback,
   recordMetric,
   flushMetrics,
+  measureFn,
+  startMoment,
+  setFeatureFlag,
+  clearFeatureFlag,
+  clearAllFeatureFlags,
+  getFeatureFlags,
   ErrorBoundary,
+  FeedbackButton,
+  RageTapCapture,
   registerMaskQuery,
   clearMaskQuery,
   startSession,
@@ -49,8 +67,18 @@ export {
   setUser,
 } from './capture';
 export { ErrorBoundary } from './error-boundary';
+export { FeedbackButton, type FeedbackButtonHandle, type FeedbackButtonProps } from './feedback-widget';
+export {
+  clearAllFeatureFlags,
+  clearFeatureFlag,
+  getFeatureFlags,
+  setFeatureFlag,
+} from './feature-flags';
 export { clearMaskQuery, registerMaskQuery } from './mask';
 export { flushMetrics, recordMetric } from './metrics';
+export { measureFn } from './measure';
+export { MomentHandle, type MomentProperties, startMoment } from '@goliapkg/sentori-core';
+export { RageTapCapture } from './rage-tap';
 export {
   startAnrWatchdog,
   stopAnrWatchdog,

package/src/init.ts

@@ -3,6 +3,11 @@ import { installGlobalHandler } from './handlers/global';
 import { installLifecycleHandler } from './handlers/lifecycle';
 import { installPromiseHandler } from './handlers/promise';
 import { installNetworkHandler } from './handlers/network';
+import { getBundleInfo } from './bundle-info';
+import {
+  markLaunchCompleted,
+  runLaunchCrashGuard,
+} from './launch-crash-guard';
 import { startMetricsTimer } from './metrics';
 import { drainNativePending, setNativeConfig } from './native';
 import { startNetworkTypeWatch } from './netinfo';
@@ -30,7 +35,14 @@ export type InitOptions = {
   capture?: {
     globalErrors?: boolean;
     promiseRejections?: boolean;
-    network?: boolean;
+    network?:
+      | boolean
+      | {
+          /** v0.9.0 #11 — auto-extract GraphQL `operationName` from
+           *  POST request bodies and use it as the breadcrumb / span
+           *  name (instead of `POST /graphql`). Default `true`. */
+          graphql?: boolean;
+        };
     /** Session tracking: opens a session on init and on each
      *  foreground (`AppState` → `active`), ends it on background.
      *  Drives crash-free rate. Set `false` to opt out. */
@@ -49,6 +61,20 @@ export type InitOptions = {
      *  the buffer is sealed and uploaded as a `sessionTrail`
      *  attachment. Defaults to false. */
     sessionTrail?: boolean;
+    /** v0.9.0 #3 — launch-crash loop guard. When two consecutive
+     *  launches don't reach `markLaunchCompleted()` (typical of an
+     *  OTA update with a fatal bug), invoke the host callback with
+     *  a 200 ms timeout to decide rollback / reset / continue. */
+    launchCrashGuard?: {
+      enabled: boolean;
+      onLaunchCrashDetected?: (
+        info: import('./launch-crash-guard').LaunchCrashInfo,
+      ) =>
+        | import('./launch-crash-guard').LaunchCrashAction
+        | Promise<import('./launch-crash-guard').LaunchCrashAction>;
+      threshold?: number;
+      timeoutMs?: number;
+    };
   };
   /** Phase 44 sub-B: client-side sampling. Each rate is `[0, 1]`;
    *  absent / null keeps everything. Defaults to 1.0 for both
@@ -76,6 +102,19 @@ export const init = (options: InitOptions): void => {
     options.environment ??
     (typeof __DEV__ !== 'undefined' && __DEV__ ? 'dev' : 'prod');
 
+  // v0.9.0 #3 — launch-crash guard. Fires *before* any other setup so
+  // a known-bad bundle can roll back instead of running JS that's
+  // about to die again. AsyncStorage-backed; if the host doesn't have
+  // it the guard is a no-op.
+  const lcg = options.capture?.launchCrashGuard;
+  if (lcg?.enabled) {
+    void runLaunchCrashGuard(
+      lcg,
+      options.release,
+      getBundleInfo()?.id ?? null,
+    );
+  }
+
   setConfig({
     token: options.token,
     release: options.release,
@@ -107,7 +146,10 @@ export const init = (options: InitOptions): void => {
   const capture = options.capture ?? {};
   if (capture.globalErrors !== false) installGlobalHandler();
   if (capture.promiseRejections !== false) installPromiseHandler();
-  if (capture.network !== false) installNetworkHandler();
+  if (capture.network !== false) {
+    const netOpts = typeof capture.network === 'object' ? capture.network : undefined;
+    installNetworkHandler({ graphql: netOpts?.graphql });
+  }
   if (capture.sessions !== false) {
     // Open the cold-start session now (RN doesn't fire an AppState
     // `change` for the initial `active` state), then bind AppState so
@@ -154,6 +196,16 @@ export const init = (options: InitOptions): void => {
     })
     .catch(() => {});
   drainOfflineQueue().catch(() => {});
+
+  // v0.9.0 #3 — init reached the end without throwing. Schedule the
+  // "launch completed" marker after one tick so any synchronous user
+  // code right after `init()` gets to run first; we want the marker to
+  // confirm the JS bridge stayed alive, not just that `init()` returned.
+  if (lcg?.enabled) {
+    setTimeout(() => {
+      void markLaunchCompleted(getBundleInfo()?.id ?? null);
+    }, 2_000);
+  }
 };
 
 /**

package/src/launch-crash-guard.ts

@@ -0,0 +1,221 @@
+// v0.9.0 #3 — launch-crash loop guard.
+//
+// On every init we write a "launch_marker" to AsyncStorage. On
+// `markLaunchCompleted()` we write a sibling "launch_completed". On
+// startup we look at the previous launch state: marker present but
+// completed missing → previous launch did not finish → increment a
+// consecutive-crash counter.
+//
+// When the counter crosses `threshold` (default 2), we invoke the
+// host-supplied `onLaunchCrashDetected` callback with a 200 ms timeout
+// (D3) and follow its action: rollback the OTA bundle, reset a list
+// of AsyncStorage keys, or continue. Rollback / reset trigger an
+// `expo-updates` reload when available.
+//
+// v0.9.0 scope: JS-only — catches everything that runs after the JS
+// bridge is up (almost every OTA-induced launch crash). v0.9.1 will
+// add a native marker for the small set of "crashed before bridge"
+// cases.
+
+const MARKER_KEY = '@sentori/launch_marker';
+const COMPLETED_KEY = '@sentori/launch_completed';
+const COUNT_KEY = '@sentori/launch_crash_count';
+
+export type LaunchCrashInfo = {
+  /** Consecutive failed launches detected so far (this one inclusive). */
+  consecutiveCount: number;
+  /** OTA bundle id of the crashing launch, if known. */
+  crashedBundle: null | string;
+  /** Most recent bundle id that *did* reach `markLaunchCompleted`. */
+  lastSafeBundle: null | string;
+  /** Store-binary release of the crashing launch. */
+  release: string;
+};
+
+export type LaunchCrashAction =
+  | { action: 'continue' }
+  | { action: 'reset'; clearKeys: string[] }
+  | { action: 'rollback'; toBundle?: null | string };
+
+export type LaunchCrashGuardOptions = {
+  enabled: boolean;
+  onLaunchCrashDetected?: (info: LaunchCrashInfo) => LaunchCrashAction | Promise<LaunchCrashAction>;
+  /** Default 2 — fires after the second consecutive failed launch. */
+  threshold?: number;
+  /** Default 200 — D3 decision. */
+  timeoutMs?: number;
+};
+
+type AsyncStorageLike = {
+  getItem: (key: string) => Promise<null | string>;
+  multiRemove?: (keys: string[]) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+  setItem: (key: string, value: string) => Promise<void>;
+};
+
+function loadAsyncStorage(): AsyncStorageLike | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('@react-native-async-storage/async-storage') as {
+      default?: AsyncStorageLike;
+    };
+    return mod.default ?? (mod as unknown as AsyncStorageLike);
+  } catch {
+    return null;
+  }
+}
+
+/** Returns `false` iff we triggered a bundle rollback / reset and
+ *  expect the app to reload momentarily; the caller (init) should
+ *  short-circuit further setup. */
+export async function runLaunchCrashGuard(
+  opts: LaunchCrashGuardOptions,
+  release: string,
+  currentBundleId: null | string,
+): Promise<{ shouldContinueInit: boolean; info?: LaunchCrashInfo }> {
+  if (!opts.enabled) return { shouldContinueInit: true };
+  const storage = loadAsyncStorage();
+  if (!storage) return { shouldContinueInit: true };
+
+  try {
+    const marker = await storage.getItem(MARKER_KEY);
+    const completed = await storage.getItem(COMPLETED_KEY);
+
+    if (marker && !completed) {
+      const m = safeJsonParse<{ bundleId?: string; lastSafeBundle?: string }>(marker) ?? {};
+      const prevCount = parseInt((await storage.getItem(COUNT_KEY)) ?? '0', 10) || 0;
+      const consecutiveCount = prevCount + 1;
+      await storage.setItem(COUNT_KEY, String(consecutiveCount));
+
+      if (consecutiveCount >= (opts.threshold ?? 2) && opts.onLaunchCrashDetected) {
+        const info: LaunchCrashInfo = {
+          consecutiveCount,
+          crashedBundle: m.bundleId ?? null,
+          lastSafeBundle: m.lastSafeBundle ?? null,
+          release,
+        };
+        const action = await raceWithTimeout<LaunchCrashAction>(
+          Promise.resolve(opts.onLaunchCrashDetected(info)),
+          opts.timeoutMs ?? 200,
+          { action: 'continue' },
+        );
+        const handled = await applyAction(action, storage);
+        if (!handled.shouldContinueInit) {
+          return { ...handled, info };
+        }
+        return { ...handled, info };
+      }
+    } else {
+      // Previous launch completed; clean the counter.
+      await storage.setItem(COUNT_KEY, '0');
+    }
+
+    // Write the marker for THIS launch. lastSafeBundle = previous
+    // completed bundle id, so the user's callback can target it.
+    const lastSafeBundle =
+      (completed && safeJsonParse<{ bundleId?: string }>(completed)?.bundleId) ?? null;
+    await storage.setItem(
+      MARKER_KEY,
+      JSON.stringify({
+        bundleId: currentBundleId,
+        lastSafeBundle,
+        release,
+        ts: Date.now(),
+      }),
+    );
+    await storage.removeItem(COMPLETED_KEY);
+  } catch {
+    // AsyncStorage glitches must never block init.
+  }
+
+  return { shouldContinueInit: true };
+}
+
+export async function markLaunchCompleted(currentBundleId: null | string): Promise<void> {
+  const storage = loadAsyncStorage();
+  if (!storage) return;
+  try {
+    await storage.setItem(
+      COMPLETED_KEY,
+      JSON.stringify({ bundleId: currentBundleId, ts: Date.now() }),
+    );
+    await storage.setItem(COUNT_KEY, '0');
+  } catch {
+    // ignore
+  }
+}
+
+async function applyAction(
+  action: LaunchCrashAction,
+  storage: AsyncStorageLike,
+): Promise<{ shouldContinueInit: boolean }> {
+  if (action.action === 'continue') return { shouldContinueInit: true };
+  if (action.action === 'reset') {
+    if (storage.multiRemove && Array.isArray(action.clearKeys)) {
+      try {
+        await storage.multiRemove(action.clearKeys);
+      } catch {
+        // ignore
+      }
+    }
+    await reloadOTAIfPossible();
+    return { shouldContinueInit: false };
+  }
+  if (action.action === 'rollback') {
+    await reloadOTAIfPossible();
+    return { shouldContinueInit: false };
+  }
+  return { shouldContinueInit: true };
+}
+
+async function reloadOTAIfPossible(): Promise<void> {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Updates = require('expo-updates') as {
+      reloadAsync?: () => Promise<void>;
+    };
+    if (typeof Updates.reloadAsync === 'function') {
+      await Updates.reloadAsync();
+    }
+  } catch {
+    // expo-updates not installed — caller will fall through and
+    // continue init; their callback returned `rollback` but we can't
+    // perform it without the OTA library. Document accordingly.
+  }
+}
+
+export function raceWithTimeout<T>(p: Promise<T>, ms: number, fallback: T): Promise<T> {
+  return new Promise<T>((resolve) => {
+    let done = false;
+    const t = setTimeout(() => {
+      if (!done) {
+        done = true;
+        resolve(fallback);
+      }
+    }, ms);
+    p.then(
+      (v) => {
+        if (!done) {
+          done = true;
+          clearTimeout(t);
+          resolve(v);
+        }
+      },
+      () => {
+        if (!done) {
+          done = true;
+          clearTimeout(t);
+          resolve(fallback);
+        }
+      },
+    );
+  });
+}
+
+function safeJsonParse<T>(s: string): null | T {
+  try {
+    return JSON.parse(s) as T;
+  } catch {
+    return null;
+  }
+}

package/src/measure.ts

@@ -0,0 +1,28 @@
+// v0.9.0 #14 — `sentori.measureFn(name, fn)`. Profile-lite. Wrap an
+// async (or sync) function call in a span so it shows on the issue
+// detail trace waterfall without writing the boilerplate every time.
+// The full Hermes-sampler profiler (#4) is the deep version of this
+// idea; `measureFn` is the cheap version that doesn't need a native
+// module.
+
+import { startSpan } from '@goliapkg/sentori-core';
+
+export async function measureFn<T>(
+  name: string,
+  fn: () => Promise<T> | T,
+  opts?: { tags?: Record<string, string> },
+): Promise<T> {
+  const span = startSpan('sentori.measureFn', {
+    name,
+    tags: opts?.tags ?? {},
+  });
+  try {
+    const result = await fn();
+    span.finish({ status: 'ok' });
+    return result;
+  } catch (e) {
+    if (e instanceof Error) span.setTag('error.message', e.message);
+    span.finish({ status: 'error' });
+    throw e;
+  }
+}

package/src/rage-tap-detector.ts

@@ -0,0 +1,26 @@
+// v0.9.0 #12 — pure rage-tap detection logic. Lives outside the .tsx
+// component so unit tests can import it without dragging in
+// `react-native` (whose flow syntax breaks bun:test parser).
+
+export const RAGE_WINDOW_MS = 800;
+export const RAGE_THRESHOLD = 3;
+
+/** Given the per-target recent-tap buckets, a target id, and `now`,
+ *  return `true` iff this tap crosses the rage threshold. Side
+ *  effect: writes/clears the bucket inside `map` so successive
+ *  taps after a triggered rage event don't immediately re-trigger. */
+export function recordTap(
+  map: Map<number, number[]>,
+  target: number,
+  now: number,
+): boolean {
+  const previous = map.get(target) ?? [];
+  const fresh = previous.filter((t) => now - t <= RAGE_WINDOW_MS);
+  fresh.push(now);
+  if (fresh.length >= RAGE_THRESHOLD) {
+    map.delete(target);
+    return true;
+  }
+  map.set(target, fresh);
+  return false;
+}

package/src/rage-tap.tsx

@@ -0,0 +1,48 @@
+// v0.9.0 #12 — rage-tap / multi-click detection.
+//
+// Wrap your app root (typically next to ErrorBoundary) with
+// `<sentori.RageTapCapture>{children}</sentori.RageTapCapture>`.
+// We listen to bubble-phase `onTouchEnd` and emit a `ui.multiClick`
+// breadcrumb when the same native target receives ≥ 3 taps within
+// 800 ms. Pure observation — no event capture, no gesture
+// interference; existing Touchables / Pressables / GestureHandler
+// continue to fire normally.
+
+import React, { useCallback, useRef } from 'react';
+import { View, type GestureResponderEvent, type ViewProps } from 'react-native';
+
+import { addBreadcrumb } from './breadcrumbs';
+import {
+  RAGE_THRESHOLD,
+  RAGE_WINDOW_MS,
+  recordTap,
+} from './rage-tap-detector';
+
+export function RageTapCapture({
+  children,
+  ...rest
+}: ViewProps & { children?: React.ReactNode }): React.JSX.Element {
+  const recent = useRef<Map<number, number[]>>(new Map());
+
+  const onTouchEnd = useCallback((e: GestureResponderEvent) => {
+    const target = e.nativeEvent?.target;
+    if (typeof target !== 'number') return;
+    if (recordTap(recent.current, target, Date.now())) {
+      addBreadcrumb({
+        type: 'user',
+        data: {
+          kind: 'ui.multiClick',
+          target: String(target),
+          taps: RAGE_THRESHOLD,
+          windowMs: RAGE_WINDOW_MS,
+        },
+      });
+    }
+  }, []);
+
+  return (
+    <View {...rest} onTouchEnd={onTouchEnd}>
+      {children}
+    </View>
+  );
+}