@goliapkg/sentori-react-native 0.7.5 → 0.8.0

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/metrics.ts

@@ -0,0 +1,74 @@
+// v0.8.3 — custom metrics buffer.
+//
+// `recordMetric(name, value, tags?)` pushes a point into a fixed-size
+// ring. A timer flushes the ring every 30 s (or when the buffer is
+// full); captureException also forces a flush so the metrics line up
+// with the error event in the dashboard. Best-effort: a flush failure
+// drops the batch on the floor — metrics aren't critical telemetry.
+//
+// Why not one fetch per point: noisy loops (`recordMetric('frame', 1)`
+// in a render hook) would burn the JS thread + saturate the device's
+// outgoing connection pool. Batching makes the SDK safe to use as a
+// cheap counter primitive.
+
+import { getConfig, isInitialized } from './config';
+import { sendMetricsBatch } from './transport';
+
+type Point = {
+  name: string;
+  tags?: Record<string, string>;
+  ts: string;
+  value: number;
+};
+
+const MAX_BUFFER = 500;
+const FLUSH_INTERVAL_MS = 30_000;
+
+let _buf: Point[] = [];
+let _timer: ReturnType<typeof setInterval> | null = null;
+
+export function recordMetric(
+  name: string,
+  value: number,
+  tags?: Record<string, string>,
+): void {
+  if (!isInitialized()) return;
+  if (typeof name !== 'string' || name.length === 0 || name.length > 200) return;
+  if (typeof value !== 'number' || !Number.isFinite(value)) return;
+  if (tags && Object.keys(tags).length > 20) return;
+  _buf.push({ name, tags, ts: new Date().toISOString(), value });
+  if (_buf.length >= MAX_BUFFER) {
+    void flushMetrics();
+  }
+}
+
+export async function flushMetrics(): Promise<void> {
+  if (_buf.length === 0) return;
+  const config = getConfig();
+  if (!config) return;
+  const batch = _buf;
+  _buf = [];
+  await sendMetricsBatch(config.ingestUrl, config.token, batch);
+}
+
+/**
+ * Start the 30 s flush timer. Called once from `init()`. Idempotent.
+ * `clearMetricsTimer` is exposed for tests / teardown.
+ */
+export function startMetricsTimer(): void {
+  if (_timer !== null) return;
+  _timer = setInterval(() => {
+    void flushMetrics();
+  }, FLUSH_INTERVAL_MS);
+  // Don't keep the process alive solely for this timer (Node would).
+  // In RN setInterval is a NoopRef so this is harmless there.
+  (_timer as unknown as { unref?: () => void }).unref?.();
+}
+
+export function __resetMetricsForTests(): void {
+  if (_timer !== null) {
+    clearInterval(_timer);
+    _timer = null;
+  }
+  _buf = [];
+}

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>
+  );
+}

package/src/transport.ts

@@ -242,6 +242,38 @@ export const sendSessionPing = async (
   }
 };
 
+/**
+ * v0.8.3 — flush a batched set of custom metrics. The host SDK
+ * batches recordMetric() calls into a fixed-size ring (drained on
+ * a timer + at next captureException) so a busy loop doesn't spin
+ * up one fetch per point. Best-effort, no retry.
+ */
+export const sendMetricsBatch = async (
+  ingestUrl: string,
+  token: string,
+  metrics: Array<{
+    name: string;
+    tags?: Record<string, string>;
+    ts?: string;
+    value: number;
+  }>,
+): Promise<void> => {
+  if (metrics.length === 0) return;
+  try {
+    await fetch(`${ingestUrl}/v1/metrics:batch`, {
+      body: JSON.stringify({ metrics }),
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'Sentori-Sdk': `react-native/${SDK_VERSION}`,
+      },
+      method: 'POST',
+    });
+  } catch {
+    // best-effort
+  }
+};
+
 /**
  * v0.8.2 — submit a user-supplied bug report. Fire-and-forget; resolves
  * with the server-assigned id on success or `null` on any failure.