@goliapkg/sentori-react-native 0.1.0

package/src/transport.ts

@@ -0,0 +1,164 @@
+import { getConfig } from './config';
+import type { Event } from './types';
+
+const FLUSH_INTERVAL_MS = 5_000;
+const BATCH_SIZE = 10;
+const MAX_RETRY = 3;
+const STORAGE_KEY = '@sentori/pending';
+const MAX_PERSISTED = 1000;
+
+let _queue: Event[] = [];
+let _flushTimer: ReturnType<typeof setTimeout> | null = null;
+let _started = false;
+
+const SDK_VERSION = '0.0.0';
+
+export const enqueue = (event: Event): void => {
+  _queue.push(event);
+  if (_queue.length >= BATCH_SIZE) {
+    void flush();
+  } else if (!_flushTimer) {
+    _flushTimer = setTimeout(() => {
+      _flushTimer = null;
+      void flush();
+    }, FLUSH_INTERVAL_MS);
+  }
+};
+
+export const startTransport = (): void => {
+  _started = true;
+};
+
+export const flush = async (): Promise<void> => {
+  if (!_started) return;
+  if (_queue.length === 0) return;
+
+  const config = getConfig();
+  if (!config) return;
+
+  const batch = _queue.splice(0, _queue.length);
+  if (_flushTimer) {
+    clearTimeout(_flushTimer);
+    _flushTimer = null;
+  }
+
+  try {
+    await sendWithRetry(batch, config.ingestUrl, config.token);
+  } catch {
+    await persist(batch);
+  }
+};
+
+const sendWithRetry = async (
+  events: Event[],
+  ingestUrl: string,
+  token: string,
+): Promise<void> => {
+  let attempt = 0;
+  let delayMs = 1000;
+  while (true) {
+    try {
+      await sendOnce(events, ingestUrl, token);
+      return;
+    } catch (e) {
+      attempt++;
+      if (attempt >= MAX_RETRY) throw e;
+      await sleep(delayMs);
+      delayMs *= 2;
+    }
+  }
+};
+
+const sendOnce = async (
+  events: Event[],
+  ingestUrl: string,
+  token: string,
+): Promise<void> => {
+  const url =
+    events.length === 1 ? `${ingestUrl}/v1/events` : `${ingestUrl}/v1/events:batch`;
+  const body = events.length === 1 ? events[0] : { events };
+
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+      'Sentori-Sdk': `react-native/${SDK_VERSION}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (resp.status === 429) {
+    let retryAfterMs = 5000;
+    try {
+      const j = (await resp.json()) as { retryAfterMs?: number };
+      if (typeof j.retryAfterMs === 'number') retryAfterMs = j.retryAfterMs;
+    } catch {
+      // ignore body parse error
+    }
+    await sleep(retryAfterMs);
+    throw new Error('rate-limited');
+  }
+
+  if (resp.status >= 500) {
+    throw new Error(`server-${resp.status}`);
+  }
+  // 4xx other than 429 = client error, drop silently
+};
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((r) => setTimeout(r, ms));
+
+type AsyncStorageLike = {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+};
+
+const getAsyncStorage = async (): Promise<AsyncStorageLike | null> => {
+  try {
+    const mod = (await import(
+      '@react-native-async-storage/async-storage'
+    )) as { default: AsyncStorageLike };
+    return mod.default;
+  } catch {
+    return null;
+  }
+};
+
+const persist = async (events: Event[]): Promise<void> => {
+  const AsyncStorage = await getAsyncStorage();
+  if (!AsyncStorage) return;
+  try {
+    const existing = await AsyncStorage.getItem(STORAGE_KEY);
+    const prev: Event[] = existing ? JSON.parse(existing) : [];
+    const merged = [...prev, ...events].slice(-MAX_PERSISTED);
+    await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(merged));
+  } catch {
+    // best-effort
+  }
+};
+
+export const drainOfflineQueue = async (): Promise<void> => {
+  const AsyncStorage = await getAsyncStorage();
+  if (!AsyncStorage) return;
+  try {
+    const raw = await AsyncStorage.getItem(STORAGE_KEY);
+    if (!raw) return;
+    await AsyncStorage.removeItem(STORAGE_KEY);
+    const events: Event[] = JSON.parse(raw);
+    for (const e of events) _queue.push(e);
+    await flush();
+  } catch {
+    // best-effort
+  }
+};
+
+export const __resetForTests = (): void => {
+  _queue = [];
+  if (_flushTimer) clearTimeout(_flushTimer);
+  _flushTimer = null;
+  _started = false;
+};
+
+export const __peekQueue = (): readonly Event[] => _queue;

package/src/types.ts

@@ -0,0 +1,63 @@
+export type Platform = 'javascript' | 'ios' | 'android';
+export type DeviceOS = 'ios' | 'android' | 'web' | 'other';
+export type EventKind = 'error';
+export type BreadcrumbType = 'nav' | 'net' | 'log' | 'user' | 'custom';
+
+export type Event = {
+  id: string;
+  timestamp: string;
+  kind: EventKind;
+  platform: Platform;
+  release: string;
+  environment: string;
+  device: Device;
+  app: App;
+  user?: User | null;
+  tags?: Tags;
+  breadcrumbs?: Breadcrumb[];
+  error: SentoriError;
+  fingerprint?: string[];
+  traceId?: string | null;
+  spanId?: string | null;
+};
+
+export type Device = {
+  os: DeviceOS;
+  osVersion: string;
+  model?: string;
+  locale?: string;
+};
+
+export type App = {
+  version: string;
+  build?: string;
+  framework?: { name: string; version: string };
+};
+
+export type User = { id?: string; anonymous?: boolean };
+
+export type Tags = Record<string, string>;
+
+export type SentoriError = {
+  type: string;
+  message: string;
+  stack: Frame[];
+  cause?: SentoriError | null;
+};
+
+export type Frame = {
+  function?: string;
+  file: string;
+  line: number;
+  column?: number;
+  inApp: boolean;
+  absolutePath?: string;
+  preContext?: string[];
+  postContext?: string[];
+};
+
+export type Breadcrumb = {
+  timestamp: string;
+  type: BreadcrumbType;
+  data: Record<string, unknown>;
+};

package/src/uuid.ts

@@ -0,0 +1,56 @@
+/**
+ * RFC 9562 UUID v7 generator.
+ * Layout:
+ *   bytes 0-5  (48 bits) — Unix epoch milliseconds, big-endian
+ *   byte 6     (high nibble) — version 7 (0x70)
+ *   byte 6     (low nibble) + byte 7 — 12 random bits
+ *   byte 8     (high 2 bits) — variant 10
+ *   byte 8     (low 6 bits) + bytes 9-15 — 62 random bits
+ */
+export const uuidV7 = (): string => {
+  const ts = Date.now();
+  const buf = new Uint8Array(16);
+
+  buf[0] = Math.floor(ts / 0x10000000000) & 0xff;
+  buf[1] = Math.floor(ts / 0x100000000) & 0xff;
+  buf[2] = Math.floor(ts / 0x1000000) & 0xff;
+  buf[3] = Math.floor(ts / 0x10000) & 0xff;
+  buf[4] = Math.floor(ts / 0x100) & 0xff;
+  buf[5] = ts & 0xff;
+
+  fillRandom(buf.subarray(6));
+
+  buf[6] = (buf[6]! & 0x0f) | 0x70; // version 7
+  buf[8] = (buf[8]! & 0x3f) | 0x80; // variant 10xx
+
+  const hex = Array.from(buf, (b) => b.toString(16).padStart(2, '0')).join('');
+  return (
+    hex.slice(0, 8) +
+    '-' +
+    hex.slice(8, 12) +
+    '-' +
+    hex.slice(12, 16) +
+    '-' +
+    hex.slice(16, 20) +
+    '-' +
+    hex.slice(20, 32)
+  );
+};
+
+const fillRandom = (buf: Uint8Array): void => {
+  // Prefer crypto.getRandomValues (Hermes 0.74+, browsers, Node, Bun).
+  // RN apps targeting older Hermes should add `react-native-get-random-values`
+  // before importing the SDK.
+  const cryptoObj = (
+    globalThis as {
+      crypto?: { getRandomValues?: (b: Uint8Array) => Uint8Array };
+    }
+  ).crypto;
+  if (cryptoObj && typeof cryptoObj.getRandomValues === 'function') {
+    cryptoObj.getRandomValues(buf);
+    return;
+  }
+  for (let i = 0; i < buf.length; i++) {
+    buf[i] = Math.floor(Math.random() * 256);
+  }
+};