@goliapkg/sentori-react-native 3.1.0 → 5.0.0

package/src/__tests__/verbs.test.ts

@@ -0,0 +1,91 @@
+// The five verbs: synchronous, never throw, id out, correct wire.
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+
+import { clearSignals } from '@goliapkg/sentori-core';
+
+import { __resetForTests as resetConfig, setConfig } from '../config';
+import { __resetForTests as resetScope } from '../scope';
+import {
+  __peekAssertStats,
+  __peekQueue,
+  __resetForTests as resetTransport,
+  startTransport,
+} from '../transport';
+import { verbs } from '../verbs';
+
+const baseConfig = {
+  token: 'st_test',
+  ingestUrl: 'http://localhost:18080',
+  release: 'app@1.0.0',
+  environment: 'test',
+  enabled: true,
+  detect: { rageTap: true, longFreeze: true, slowColdStart: true, slowApi: false },
+  replaySeconds: 30,
+};
+
+describe('the five verbs', () => {
+  beforeEach(() => {
+    resetTransport();
+    resetConfig();
+    resetScope();
+    clearSignals();
+    setConfig(baseConfig);
+    startTransport();
+  });
+  afterEach(() => {
+    resetTransport();
+    resetConfig();
+    resetScope();
+    clearSignals();
+  });
+
+  it('error coerces anything and enqueues with a stack', () => {
+    const id = verbs.error(new Error('boom'));
+    expect(typeof id).toBe('string');
+    const q = __peekQueue();
+    expect(q.length).toBe(1);
+    expect(q[0]?.kind).toBe('error');
+    expect(q[0]?.payload.error?.type).toBe('Error');
+    expect(q[0]?.payload.error?.message).toBe('boom');
+  });
+
+  it('error serializes Error instances found in data (error-in-data)', () => {
+    verbs.warn('pay.retry', { attempt: 2, error: new TypeError('nope') });
+    const q = __peekQueue();
+    const data = q[0]?.payload.data as { error?: { type?: string } };
+    expect(data.error?.type).toBe('TypeError');
+  });
+
+  it('warn carries name; trace quiet stays out of the queue', () => {
+    verbs.warn('rage_tap');
+    expect(__peekQueue().length).toBe(1);
+    verbs.trace('checkout.start', undefined, { quiet: true });
+    expect(__peekQueue().length).toBe(1); // unchanged
+    verbs.trace('checkout.start');
+    expect(__peekQueue().length).toBe(2);
+  });
+
+  it('assert pass aggregates without an event; fail is an event', () => {
+    verbs.assert('total-positive', true);
+    expect(__peekQueue().length).toBe(0);
+    expect(__peekAssertStats()[0]?.passDelta).toBe(1);
+    verbs.assert('total-positive', false);
+    expect(__peekQueue().length).toBe(1);
+    expect(__peekQueue()[0]?.kind).toBe('assert');
+  });
+
+  it('probe never throws and reports the ref as name', () => {
+    const id = verbs.probe('SENT-123');
+    expect(typeof id).toBe('string');
+    expect(__peekQueue()[0]?.kind).toBe('probe');
+    expect(__peekQueue()[0]?.name).toBe('SENT-123');
+  });
+
+  it('before init everything is a silent no-op that still returns an id', () => {
+    resetConfig();
+    const id = verbs.error(new Error('x'));
+    expect(typeof id).toBe('string');
+    expect(__peekQueue().length).toBe(0);
+  });
+});

package/src/config.ts

@@ -1,58 +1,30 @@
-import type { BeforeSendHook, LogLevel, ReadyInfo } from '@goliapkg/sentori-core';
+// SDK-internal runtime config, set once by init(). Everything else
+// reads through getConfig() and treats null as "not initialized →
+// every verb is a no-op" (the failure-isolation iron rule).
 
-/**
- * v2.3 — `ReadyInfo` is shared across SDKs via `@goliapkg/sentori-core`
- * so a host that switches from web to RN reads the same shape. The RN
- * SDK always populates `native` + `coldStartMs`; the core type marks
- * both optional for the web SDK's benefit (web has no native module).
- */
-export type { ReadyInfo };
+import type { LogLevel, WireEvent } from '@goliapkg/sentori-core';
 
 export type Config = {
   token: string;
+  ingestUrl: string;
   release: string;
   environment: string;
-  ingestUrl: string;
   enabled: boolean;
-  /** Phase 42 sub-D.07: opt-in screenshot capture on captureException. */
-  screenshotsEnabled: boolean;
-  /** Phase 44 sub-B: per-event-class sampling rates 0..1.
-   *  `null` = keep everything (default). */
-  errorSampleRate: null | number;
-  traceSampleRate: null | number;
-  /** v2.0 — sampling rate for `kind: 'message'` events emitted via
-   *  `captureMessage`. `null` = keep all (default). */
-  messageSampleRate: null | number;
-  /** Phase 46: when true, every `captureException` seals the
-   *  session-trail buffer and uploads it as a `sessionTrail`
-   *  attachment. Defaults to false. */
-  sessionTrailEnabled: boolean;
-  /** v2.0 W3 — when true, every `track(name, props)` call also
-   *  pushes a `{ type: 'track', data: { name, props } }` breadcrumb
-   *  so a subsequent capture carries the customer journey. Defaults
-   *  to false to preserve v1 customer breadcrumb shape on upgrade. */
-  trackAutoBreadcrumb: boolean;
-  /** v2.3 — Sentori console output gate.
-   *
-   *  Default `warn`: SDK is silent on host's console unless
-   *  something is genuinely broken (transport sustained failure,
-   *  native module not found, internal SDK exception). No
-   *  per-tick / per-init / per-breadcrumb noise.
-   *
-   *  Set `'silent'` for absolute silence (e.g. CI smoke runs);
-   *  set `'info'` or `'debug'` when debugging Sentori itself. */
+  /** Warn-scenario auto-detection switches (conservative defaults). */
+  detect: {
+    rageTap: boolean;
+    longFreeze: boolean;
+    slowColdStart: boolean;
+    slowApi: boolean;
+  };
+  /** B-type replay rolling buffer, seconds. 0 disables. */
+  replaySeconds: number;
+  /** Sentori console output gate. Default `warn`: silent on the
+   *  host's console unless something is genuinely broken. */
   logLevel?: LogLevel;
-  /** v2.3 — fires once after init completes. Use this to know the
-   *  SDK is live instead of scanning the console. `info` carries
-   *  the native-module bind status + cold-start timing. Host
-   *  wraps any host-side logging here. */
-  onReady?: (info: ReadyInfo) => void;
-  /** v2.3 — host-side mutate-or-drop hook called once per event
-   *  just before transport enqueue. Return the event to send it,
-   *  `null` to drop. Sync only. If the hook throws or returns a
-   *  non-event, SDK falls back to the un-mutated event and emits
-   *  one one-shot warn. */
-  beforeSend?: BeforeSendHook;
+  /** Host-side mutate-or-drop hook, sync only. Throw / bad return →
+   *  the un-mutated event ships and one warn is emitted. */
+  beforeSend?: (event: WireEvent) => WireEvent | null;
 };
 
 let _config: Config | null = null;

package/src/device.ts

@@ -0,0 +1,36 @@
+// Synchronous device snapshot — what the JS layer can know without
+// crossing the bridge. The native module enriches asynchronously via
+// setNativeDeviceInfo at init; until then the JS-visible subset
+// ships (an event with a thin device beats a delayed event).
+
+import type { Device } from '@goliapkg/sentori-core';
+
+let _native: Partial<Device> | null = null;
+
+export const setNativeDeviceInfo = (info: Partial<Device>): void => {
+  _native = info;
+};
+
+export const collectDevice = (): Device | undefined => {
+  let base: Device | undefined;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const RN = require('react-native') as {
+      Platform?: { OS?: string; Version?: number | string };
+      Dimensions?: { get(dim: string): { width: number; height: number; scale: number } };
+    };
+    const os = RN.Platform?.OS ?? 'unknown';
+    base = { os, osVersion: RN.Platform?.Version?.toString() };
+    const win = RN.Dimensions?.get('window');
+    if (win) {
+      base.screen = { width: win.width, height: win.height, scale: win.scale };
+    }
+  } catch {
+    return _native ? ({ os: 'unknown', ..._native } as Device) : undefined;
+  }
+  return _native ? { ...base, ..._native } : base;
+};
+
+export const __resetForTests = (): void => {
+  _native = null;
+};

package/src/emit-hooks.ts

@@ -0,0 +1,30 @@
+// Post-emit hooks — how B-type replay (and future reactions) learn
+// "an event just went out" without the verbs knowing about them.
+//
+// Hooks run inside their own try/catch: a broken subscriber must
+// never take the emit path down with it (failure isolation).
+
+import type { WireEvent } from '@goliapkg/sentori-core';
+import { reportInternal } from '@goliapkg/sentori-core';
+
+type EmitHook = (event: WireEvent) => void;
+
+const hooks: EmitHook[] = [];
+
+export const registerEmitHook = (hook: EmitHook): void => {
+  hooks.push(hook);
+};
+
+export const onEventEmitted = (event: WireEvent): void => {
+  for (const hook of hooks) {
+    try {
+      hook(event);
+    } catch (e) {
+      reportInternal('emit-hook', e);
+    }
+  }
+};
+
+export const __resetForTests = (): void => {
+  hooks.length = 0;
+};

package/src/error-boundary.tsx

@@ -1,6 +1,6 @@
 import React, { Component, type ErrorInfo, type ReactNode } from 'react';
 
-import { captureError } from './capture';
+import { error as captureError } from  "./verbs";
 
 export type ErrorBoundaryProps = {
   fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);

package/src/handlers/dev-symbolicate.ts

@@ -7,7 +7,7 @@
 // Best-effort and dev-only: any failure (Metro not running, timeout,
 // bad response) leaves the stack untouched. Never throws.
 
-import type { Frame, SentoriError } from '../types';
+import type { Frame, SentoriError } from '@goliapkg/sentori-core';
 
 const TIMEOUT_MS = 2000;
 
@@ -132,6 +132,7 @@ export async function symbolicateErrorViaMetro(
   err: SentoriError,
   opts: { url?: string } = {},
 ): Promise<void> {
+  if (!err.stack) return;
   const sym = await symbolicateStackViaMetro(err.stack, opts);
   if (sym) err.stack = sym;
   if (err.cause) await symbolicateErrorViaMetro(err.cause, opts);

package/src/handlers/global.ts

@@ -1,4 +1,4 @@
-import { captureError } from '../capture';
+import { error as captureError } from '../verbs';
 
 type ErrorUtilsHandler = (error: Error, isFatal?: boolean) => void;
 

package/src/handlers/lifecycle.ts

@@ -12,7 +12,7 @@
  * twice". Sentry historically did the opposite (treat inactive as
  * still alive), but that lets a swiped-away session never end.
  */
-import { endSession, startSession } from '../session-tracker';
+import { pushSignal } from '@goliapkg/sentori-core';
 
 let _installed = false;
 let _subscription: { remove: () => void } | null = null;
@@ -40,9 +40,9 @@ export const installLifecycleHandler = (): void => {
 
   _subscription = AppState.addEventListener('change', (state) => {
     if (state === 'active') {
-      startSession();
+      pushSignal('lifecycle', { state: 'active' });
     } else if (state === 'background' || state === 'inactive') {
-      endSession();
+      pushSignal('lifecycle', { state: 'background' });
     }
   });
 };