@goliapkg/sentori-react-native 0.7.6 → 0.8.0

package/src/__tests__/measure.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import { clearSpans, drainSpans } from '@goliapkg/sentori-core';
+
+import { measureFn } from '../measure';
+
+afterEach(() => {
+  clearSpans();
+});
+
+describe('measureFn', () => {
+  test('runs fn, returns result, emits an ok span', async () => {
+    const r = await measureFn('addToCart', async () => 42);
+    expect(r).toBe(42);
+    const spans = drainSpans();
+    expect(spans.length).toBe(1);
+    expect(spans[0]!.op).toBe('sentori.measureFn');
+    expect(spans[0]!.name).toBe('addToCart');
+    expect(spans[0]!.status).toBe('ok');
+  });
+
+  test('supports sync fn too (Promise.resolve hides the difference)', async () => {
+    const r = await measureFn('syncJob', () => 'hello');
+    expect(r).toBe('hello');
+    expect(drainSpans()[0]!.status).toBe('ok');
+  });
+
+  test('propagates thrown errors and marks span as error', async () => {
+    await expect(
+      measureFn('failing', async () => {
+        throw new Error('nope');
+      }),
+    ).rejects.toThrow('nope');
+    const spans = drainSpans();
+    expect(spans.length).toBe(1);
+    expect(spans[0]!.status).toBe('error');
+    expect(spans[0]!.tags['error.message']).toBe('nope');
+  });
+
+  test('passes through caller tags', async () => {
+    await measureFn('withTags', async () => 'ok', { tags: { region: 'jp' } });
+    const spans = drainSpans();
+    expect(spans[0]!.tags.region).toBe('jp');
+  });
+});

package/src/__tests__/network-graphql.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import { parseGqlOpName } from '../handlers/network';
+
+// v0.9.0 #11 — covers the GraphQL operation extraction logic. The
+// patched fetch / XHR plumbing is exercised by manual smoke; this file
+// nails the parser, which is the part with branchy logic.
+
+afterEach(() => {
+  // nothing — parseGqlOpName is pure.
+});
+
+describe('parseGqlOpName', () => {
+  test('extracts operationName from a standard Apollo POST body', () => {
+    const body = JSON.stringify({
+      query: 'query UpdateCart($id:ID!){...}',
+      operationName: 'UpdateCart',
+      variables: { id: 'c-1' },
+    });
+    expect(parseGqlOpName(body)).toBe('UpdateCart');
+  });
+
+  test('extracts operationName from a batched array body (Apollo Link Batch)', () => {
+    const body = JSON.stringify([
+      { query: '...', operationName: 'FirstOp', variables: {} },
+      { query: '...', operationName: 'SecondOp', variables: {} },
+    ]);
+    expect(parseGqlOpName(body)).toBe('FirstOp');
+  });
+
+  test('falls back to sniffing the query string when operationName is absent', () => {
+    const body = JSON.stringify({
+      query: 'mutation CompleteCheckout($id:ID!){...}',
+    });
+    expect(parseGqlOpName(body)).toBe('CompleteCheckout');
+  });
+
+  test('sniffs application/graphql body (no JSON wrapper)', () => {
+    const body = 'query   ListOrders {\n  orders { id }\n}';
+    expect(parseGqlOpName(body)).toBe('ListOrders');
+  });
+
+  test('returns undefined for non-graphql JSON', () => {
+    const body = JSON.stringify({ hello: 'world' });
+    expect(parseGqlOpName(body)).toBeUndefined();
+  });
+
+  test('returns undefined for malformed JSON', () => {
+    expect(parseGqlOpName('{not json')).toBeUndefined();
+  });
+
+  test('returns undefined for an empty body', () => {
+    expect(parseGqlOpName('')).toBeUndefined();
+  });
+
+  test('rejects bodies larger than 8 KB', () => {
+    const big = JSON.stringify({
+      query: 'query Big {...}',
+      operationName: 'Big',
+      variables: { padding: 'x'.repeat(10_000) },
+    });
+    expect(parseGqlOpName(big)).toBeUndefined();
+  });
+
+  test('rejects an operationName that is too long (>200 chars)', () => {
+    const long = 'A'.repeat(201);
+    const body = JSON.stringify({ query: 'q', operationName: long });
+    expect(parseGqlOpName(body)).toBeUndefined();
+  });
+
+  test('handles leading comments in raw query body', () => {
+    const body = '# a comment\n# another comment\nsubscription LiveTicker {...}';
+    expect(parseGqlOpName(body)).toBe('LiveTicker');
+  });
+});

package/src/__tests__/rage-tap.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from 'bun:test';
+
+import { recordTap } from '../rage-tap-detector';
+
+describe('recordTap', () => {
+  test('two fast taps do not trip rage', () => {
+    const m = new Map<number, number[]>();
+    expect(recordTap(m, 7, 0)).toBe(false);
+    expect(recordTap(m, 7, 200)).toBe(false);
+    expect(m.get(7)?.length).toBe(2);
+  });
+
+  test('three fast taps on the same target trip rage', () => {
+    const m = new Map<number, number[]>();
+    recordTap(m, 7, 0);
+    recordTap(m, 7, 200);
+    expect(recordTap(m, 7, 400)).toBe(true);
+    // bucket cleared so the very next tap doesn't immediately re-trip
+    expect(m.get(7)).toBeUndefined();
+  });
+
+  test('taps spread over > 800 ms do not trip', () => {
+    const m = new Map<number, number[]>();
+    recordTap(m, 7, 0);
+    recordTap(m, 7, 500);
+    expect(recordTap(m, 7, 1500)).toBe(false);
+    // only the last (since it landed > 800ms after the previous two)
+    expect(m.get(7)?.length).toBe(1);
+  });
+
+  test('different targets do not pool', () => {
+    const m = new Map<number, number[]>();
+    recordTap(m, 1, 0);
+    recordTap(m, 2, 0);
+    recordTap(m, 3, 0);
+    expect(m.size).toBe(3);
+  });
+});

package/src/bundle-info.ts

@@ -0,0 +1,95 @@
+// v0.9.0 #10 — EAS Update / CodePush awareness.
+//
+// At capture time we want to know which JS bundle the user is running:
+// it's almost always an OTA update rather than the binary `release`,
+// and crash spikes correlate to a specific bundle id rather than the
+// app version. We try `expo-updates` first (EAS), then `react-native-
+// code-push`, then nothing. All access is `require()`-shielded so the
+// SDK still works when neither is installed.
+//
+// Cached at module load — bundle id doesn't change mid-session in
+// either Expo or CodePush.
+
+export type BundleInfo = {
+  /** Stable identifier — Expo `updateId` or CodePush `label`. */
+  id: string;
+  /** When the bundle was published. RFC 3339. */
+  deployedAt?: string;
+  /** Which OTA system reported it. */
+  source: 'codepush' | 'expo';
+};
+
+let _cached: BundleInfo | null | undefined;
+
+export function getBundleInfo(): BundleInfo | null {
+  if (_cached !== undefined) return _cached;
+  _cached = detect();
+  return _cached;
+}
+
+function detect(): BundleInfo | null {
+  // Expo Updates first — most modern RN deployments are on EAS Update.
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const Updates = require('expo-updates') as {
+      commitTime?: Date | null;
+      isEmbeddedLaunch?: boolean;
+      manifest?: { id?: string; createdAt?: string };
+      updateId?: null | string;
+    };
+    const id = Updates.updateId ?? Updates.manifest?.id;
+    if (typeof id === 'string' && id.length > 0) {
+      const deployedAt = pickDeployedAt(Updates);
+      return { deployedAt, id, source: 'expo' };
+    }
+  } catch {
+    // expo-updates not installed
+  }
+  // CodePush fallback.
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const cp = require('react-native-code-push') as {
+      getCurrentPackage?: () => Promise<{
+        appVersion?: string;
+        label?: string;
+        packageHash?: string;
+      } | null>;
+    };
+    // `getCurrentPackage` is async; we don't block init. Schedule a
+    // background fetch + populate the cache. First-event-after-init
+    // may miss the bundle id; subsequent events will have it.
+    if (typeof cp.getCurrentPackage === 'function') {
+      void cp
+        .getCurrentPackage()
+        .then((pkg) => {
+          if (pkg && (pkg.label || pkg.packageHash)) {
+            _cached = {
+              id: pkg.label ?? pkg.packageHash!,
+              source: 'codepush',
+            };
+          }
+        })
+        .catch(() => {
+          // ignore
+        });
+    }
+  } catch {
+    // not installed
+  }
+  return null;
+}
+
+function pickDeployedAt(u: {
+  commitTime?: Date | null;
+  manifest?: { createdAt?: string };
+}): string | undefined {
+  if (u.commitTime instanceof Date) return u.commitTime.toISOString();
+  const ts = u.manifest?.createdAt;
+  if (typeof ts === 'string') return ts;
+  return undefined;
+}
+
+/** Test-only — reset cache. */
+export function __resetBundleInfoForTests(): void {
+  _cached = undefined;
+}

package/src/capture.ts

@@ -1,7 +1,9 @@
 import { sealTrail, shouldSample } from '@goliapkg/sentori-core';
 
 import { addBreadcrumb, getBreadcrumbs } from './breadcrumbs';
+import { getBundleInfo } from './bundle-info';
 import { getConfig, isInitialized } from './config';
+import { getFeatureFlagSnapshot } from './feature-flags';
 import { symbolicateErrorViaMetro } from './handlers/dev-symbolicate';
 import { captureScreenshot } from './handlers/screenshot';
 import { markSessionErrored } from './session-tracker';
@@ -97,6 +99,8 @@ export const captureError = (error: Error, extras?: CaptureExtras): void => {
     return;
   }
 
+  const flags = getFeatureFlagSnapshot();
+  const bundle = getBundleInfo();
   const event: Event = {
     id: uuidV7(),
     timestamp: new Date().toISOString(),
@@ -108,6 +112,8 @@ export const captureError = (error: Error, extras?: CaptureExtras): void => {
     app: collectApp(config.release),
     user: extras?.user ?? _user,
     tags: extras?.tags,
+    ...(flags ? { flags } : {}),
+    ...(bundle ? { bundle } : {}),
     breadcrumbs: getBreadcrumbs(),
     error: errorToObject(error),
     fingerprint: extras?.fingerprint,

package/src/feature-flags.ts

@@ -0,0 +1,47 @@
+// v0.9.0 #13 — feature-flag dimensionality.
+//
+// `sentori.setFeatureFlag(name, value)` is the dual of `setTag()` for
+// experiment / flag state: distinct dashboard dimension, dense small
+// strings, designed to be filtered/faceted on. Bugsnag's analog has
+// proven surprisingly load-bearing. Implementation is a tiny in-memory
+// map; every capture rides along the current snapshot.
+//
+// Constraints (silent — never throw):
+//   • name and value are strings, length 1..200
+//   • cap at 50 distinct flags to bound payload
+//   • already-set name can update (no cap check)
+
+const MAX_FLAGS = 50;
+const MAX_LEN = 200;
+
+let _flags = new Map<string, string>();
+
+export const setFeatureFlag = (name: string, value: string): void => {
+  if (typeof name !== 'string' || name.length === 0 || name.length > MAX_LEN) return;
+  if (typeof value !== 'string' || value.length > MAX_LEN) return;
+  if (_flags.size >= MAX_FLAGS && !_flags.has(name)) return;
+  _flags.set(name, value);
+};
+
+export const clearFeatureFlag = (name: string): void => {
+  _flags.delete(name);
+};
+
+export const clearAllFeatureFlags = (): void => {
+  _flags.clear();
+};
+
+export const getFeatureFlags = (): Record<string, string> => {
+  return Object.fromEntries(_flags);
+};
+
+/** Internal — capture.ts pulls a snapshot per event. Empty object
+ *  collapses out of the payload via `Object.keys.length === 0` check. */
+export const getFeatureFlagSnapshot = (): null | Record<string, string> => {
+  if (_flags.size === 0) return null;
+  return Object.fromEntries(_flags);
+};
+
+export const __resetFeatureFlagsForTests = (): void => {
+  _flags.clear();
+};

package/src/handlers/network.ts

@@ -4,9 +4,15 @@ import { addBreadcrumb } from '../breadcrumbs';
 import { getConfig } from '../config';
 
 let _installed = false;
+let _graphqlEnabled = true;
 
 const AUTH_PARAMS = ['token', 'key', 'password', 'secret', 'access_token'];
 
+// v0.9.0 #11 — cap on body size we'll parse for `operationName`.
+// 8 KB is generous for any sensible GraphQL request and keeps the
+// hot-path JSON.parse bounded.
+const GQL_BODY_MAX_BYTES = 8 * 1024;
+
 // Requests to our own ingest endpoint shouldn't be traced — otherwise
 // every span upload spawns another http.client span, and so on.
 const isIngestUrl = (url: string): boolean => {
@@ -14,13 +20,20 @@ const isIngestUrl = (url: string): boolean => {
   return !!base && url.startsWith(base);
 };
 
-export const installNetworkHandler = (): void => {
+export const installNetworkHandler = (opts?: { graphql?: boolean }): void => {
   if (_installed) return;
   _installed = true;
+  _graphqlEnabled = opts?.graphql !== false;
   patchFetch();
   patchXhr();
 };
 
+/** Test-only — reset module state between runs. */
+export const __resetNetworkHandlerForTests = (): void => {
+  _installed = false;
+  _graphqlEnabled = true;
+};
+
 // ── fetch ──────────────────────────────────────────────────────────
 
 function patchFetch(): void {
@@ -37,13 +50,32 @@ function patchFetch(): void {
         ? (input as Request).method
         : 'GET')) as string;
 
+    // v0.9.0 #11 — GraphQL operation auto-naming. Inspect the request
+    // body cheaply (string only, < 8 KB) when the request looks like
+    // GraphQL (URL contains /graphql or content-type hints it). On
+    // success we override the span name to `graphql/<operationName>`
+    // and ride along `gql.operation` on the breadcrumb so the dashboard
+    // can group + filter by operation instead of by the useless
+    // `POST /graphql` line.
+    const gqlOp = _graphqlEnabled
+      ? extractGraphqlOpFromInit(init, input, url)
+      : undefined;
+
     // Phase 35 sub-C: also open an http.client span so the request
     // shows up in the trace waterfall. Breadcrumbs stay — they're
     // attached to error events at capture time and serve a different
     // surface (the "last 100 things" timeline on the issue page).
     const span = startSpan('http.client', {
-      name: `${method.toUpperCase()} ${normalizeUrl(scrubbed)}`,
-      tags: { 'http.method': method.toUpperCase(), 'http.url': scrubbed },
+      name: gqlOp
+        ? `graphql/${gqlOp}`
+        : `${method.toUpperCase()} ${normalizeUrl(scrubbed)}`,
+      tags: gqlOp
+        ? {
+            'http.method': method.toUpperCase(),
+            'http.url': scrubbed,
+            'gql.operation': gqlOp,
+          }
+        : { 'http.method': method.toUpperCase(), 'http.url': scrubbed },
     });
 
     // Inject traceparent header on outbound requests.
@@ -58,12 +90,20 @@ function patchFetch(): void {
       span.finish({ status: resp.status >= 400 ? 'error' : 'ok' });
       addBreadcrumb({
         type: 'net',
-        data: {
-          method,
-          url: scrubbed,
-          status: resp.status,
-          durationMs: Date.now() - start,
-        },
+        data: gqlOp
+          ? {
+              method,
+              url: scrubbed,
+              status: resp.status,
+              durationMs: Date.now() - start,
+              'gql.operation': gqlOp,
+            }
+          : {
+              method,
+              url: scrubbed,
+              status: resp.status,
+              durationMs: Date.now() - start,
+            },
       });
       return resp;
     } catch (e) {
@@ -78,6 +118,7 @@ function patchFetch(): void {
           status: 0,
           durationMs: Date.now() - start,
           error: String(e),
+          ...(gqlOp ? { 'gql.operation': gqlOp } : {}),
         },
       });
       throw e;
@@ -98,6 +139,7 @@ type TracedXhr = XMLHttpRequest & {
   __sentoriUrl?: string;
   __sentoriSpan?: ReturnType<typeof startSpan>;
   __sentoriStart?: number;
+  __sentoriGqlOp?: string;
 };
 
 function patchXhr(): void {
@@ -129,9 +171,20 @@ function patchXhr(): void {
     if (isIngestUrl(this.__sentoriUrl ?? '')) return originalSend.call(this, body);
     const method = this.__sentoriMethod ?? 'GET';
     const url = scrubUrl(this.__sentoriUrl ?? '');
+    // v0.9.0 #11 — GraphQL operation auto-naming on XHR.
+    const gqlOp = _graphqlEnabled
+      ? extractGraphqlOpFromXhr(body, this.__sentoriUrl ?? '')
+      : undefined;
+    this.__sentoriGqlOp = gqlOp;
     const span = startSpan('http.client', {
-      name: `${method} ${normalizeUrl(url)}`,
-      tags: { 'http.method': method, 'http.url': url },
+      name: gqlOp ? `graphql/${gqlOp}` : `${method} ${normalizeUrl(url)}`,
+      tags: gqlOp
+        ? {
+            'http.method': method,
+            'http.url': url,
+            'gql.operation': gqlOp,
+          }
+        : { 'http.method': method, 'http.url': url },
     });
     this.__sentoriSpan = span;
     this.__sentoriStart = Date.now();
@@ -154,14 +207,23 @@ function patchXhr(): void {
       // status 0 means network error / aborted / CORS block — treat
       // as error. The `abort` event handler below downgrades aborts.
       s.finish({ status: status === 0 || status >= 400 ? 'error' : 'ok' });
+      const op = this.__sentoriGqlOp;
       addBreadcrumb({
         type: 'net',
-        data: {
-          method,
-          url,
-          status,
-          durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
-        },
+        data: op
+          ? {
+              method,
+              url,
+              status,
+              durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
+              'gql.operation': op,
+            }
+          : {
+              method,
+              url,
+              status,
+              durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
+            },
       });
     };
 
@@ -171,9 +233,17 @@ function patchXhr(): void {
       if (!s) return;
       this.__sentoriSpan = undefined;
       s.finish({ status: 'cancelled' });
+      const op = this.__sentoriGqlOp;
       addBreadcrumb({
         type: 'net',
-        data: { method, url, status: 0, durationMs: Date.now() - (this.__sentoriStart ?? Date.now()), error: 'aborted' },
+        data: {
+          method,
+          url,
+          status: 0,
+          durationMs: Date.now() - (this.__sentoriStart ?? Date.now()),
+          error: 'aborted',
+          ...(op ? { 'gql.operation': op } : {}),
+        },
       });
     });
 
@@ -224,3 +294,113 @@ const scrubUrl = (url: string): string => {
     return url;
   }
 };
+
+// ── v0.9.0 #11 — GraphQL operation extraction ─────────────────────
+//
+// Cheap, sync, never throws. Two callers (fetch + xhr) feed in
+// whatever they have on hand; both end up calling `parseGqlOpName`.
+
+function lookGraphqlish(url: string, contentType?: string): boolean {
+  if (contentType) {
+    if (contentType.includes('graphql')) return true;
+    // application/json is too generic to gate on alone, but combined
+    // with a `/graphql` path it's a strong hint.
+  }
+  if (url.includes('/graphql')) return true;
+  return false;
+}
+
+/** Pull `operationName` out of a JSON body or a raw query body. Returns
+ *  `undefined` on any failure mode. Cap at GQL_BODY_MAX_BYTES so a
+ *  hostile / oversize body never lands in `JSON.parse`. */
+export function parseGqlOpName(body: string): string | undefined {
+  if (typeof body !== 'string' || body.length === 0) return undefined;
+  if (body.length > GQL_BODY_MAX_BYTES) return undefined;
+  // First char `{` or `[` → JSON path. Most clients (Apollo, urql,
+  // Relay) send `{"query":"…","operationName":"…","variables":{…}}`
+  // or an array of such objects (batched).
+  const first = body.charCodeAt(0);
+  if (first === 0x7b /* { */ || first === 0x5b /* [ */) {
+    try {
+      const parsed = JSON.parse(body) as unknown;
+      const candidate = Array.isArray(parsed) ? parsed[0] : parsed;
+      if (candidate && typeof candidate === 'object') {
+        const name = (candidate as { operationName?: unknown }).operationName;
+        if (typeof name === 'string' && name.length > 0 && name.length <= 200) {
+          return name;
+        }
+        // No operationName — try to sniff the `query` string for
+        // `query Foo {…}` / `mutation Bar {…}` / `subscription Baz {…}`.
+        const q = (candidate as { query?: unknown }).query;
+        if (typeof q === 'string') return parseQueryStringOpName(q);
+      }
+    } catch {
+      return undefined;
+    }
+    return undefined;
+  }
+  // `application/graphql` body is the bare query string — no JSON wrapper.
+  return parseQueryStringOpName(body);
+}
+
+function parseQueryStringOpName(query: string): string | undefined {
+  // Skip leading whitespace + comments. We only need the first non-trivial
+  // top-level operation keyword to extract a name; nested operations are
+  // a non-issue because GraphQL forbids them.
+  const m = /^\s*(?:#[^\n]*\n\s*)*(query|mutation|subscription)\s+([A-Za-z_][A-Za-z0-9_]*)/.exec(
+    query,
+  );
+  return m?.[2];
+}
+
+function extractGraphqlOpFromInit(
+  init: RequestInit | undefined,
+  input: RequestInfo | URL,
+  url: string,
+): string | undefined {
+  const method = (init?.method ??
+    (typeof input !== 'string' && 'method' in (input as Request)
+      ? (input as Request).method
+      : 'GET')) as string;
+  if (method.toUpperCase() !== 'POST') return undefined;
+  const contentType = headerValue(init, input, 'content-type');
+  if (!lookGraphqlish(url, contentType)) return undefined;
+  const body = init?.body;
+  if (typeof body !== 'string') return undefined;
+  return parseGqlOpName(body);
+}
+
+function extractGraphqlOpFromXhr(
+  body: Document | XMLHttpRequestBodyInit | null | undefined,
+  url: string,
+): string | undefined {
+  if (typeof body !== 'string') return undefined;
+  if (!lookGraphqlish(url)) return undefined;
+  return parseGqlOpName(body);
+}
+
+function headerValue(
+  init: RequestInit | undefined,
+  input: RequestInfo | URL,
+  name: string,
+): string | undefined {
+  const target = name.toLowerCase();
+  if (init?.headers) {
+    try {
+      const h = new Headers(init.headers);
+      const v = h.get(target);
+      if (v) return v;
+    } catch {
+      // ignore — bad header shape, treat as absent
+    }
+  }
+  if (typeof input !== 'string' && !(input instanceof URL)) {
+    try {
+      const v = (input as Request).headers.get(target);
+      if (v) return v;
+    } catch {
+      // ignore
+    }
+  }
+  return undefined;
+}

package/src/index.ts

@@ -9,8 +9,17 @@ import {
   setUser,
 } from './capture';
 import { ErrorBoundary } from './error-boundary';
+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 +37,14 @@ export const sentori = {
   sendUserFeedback,
   recordMetric,
   flushMetrics,
+  measureFn,
+  startMoment,
+  setFeatureFlag,
+  clearFeatureFlag,
+  clearAllFeatureFlags,
+  getFeatureFlags,
   ErrorBoundary,
+  RageTapCapture,
   registerMaskQuery,
   clearMaskQuery,
   startSession,
@@ -49,8 +65,17 @@ export {
   setUser,
 } from './capture';
 export { ErrorBoundary } from './error-boundary';
+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,