@barrysolomon/mobile-react-native 0.1.0-alpha

package/src/instrumentation/touch.ts

@@ -0,0 +1,32 @@
+/**
+ * Touch telemetry helpers (opt-in).
+ *
+ * `withTapTelemetry(target, handler?, extraAttrs?)` returns a press handler
+ * that emits a `ui.tap` log before forwarding the call. Attribute names
+ * match Android's `TapInstrumentation` so cross-platform dashboards line up.
+ */
+
+import { Dash0Mobile } from '../index';
+import type { Attributes } from '../bridge/types';
+
+const SEVERITY_INFO = 9 as const;
+
+type Handler<Args extends unknown[], R> = (...args: Args) => R;
+
+export function withTapTelemetry<Args extends unknown[], R>(
+  target: string,
+  handler?: Handler<Args, R>,
+  extraAttrs?: Attributes,
+): Handler<Args, R | undefined> {
+  return function wrappedOnPress(...args: Args): R | undefined {
+    Dash0Mobile.log(
+      'ui.tap',
+      {
+        'ui.target': target,
+        ...(extraAttrs ?? {}),
+      },
+      SEVERITY_INFO,
+    );
+    return handler ? handler(...args) : undefined;
+  };
+}

package/src/instrumentation/unhandledRejection.ts

@@ -0,0 +1,75 @@
+/**
+ * Unhandled promise rejection auto-instrumentation for React Native.
+ *
+ * Shares a dedupe window with the sync error handler so a thrown Error and
+ * its rejected-promise twin collapse to one log — matches Android's
+ * ErrorInstrumentation dedupe semantics.
+ */
+
+import { Dash0Mobile } from '../index';
+
+const DEDUPE_WINDOW_MS = 5 * 60 * 1000;
+const SEVERITY_ERROR = 17 as const;
+
+type RejectionEvent = { reason: unknown };
+type RejectionListener = (ev: RejectionEvent) => void;
+
+interface GlobalWithEventTarget {
+  addEventListener?: (type: string, listener: RejectionListener) => void;
+  removeEventListener?: (type: string, listener: RejectionListener) => void;
+}
+
+function dedupeKey(reason: unknown): string {
+  if (reason instanceof Error) {
+    return `${reason.name ?? 'Error'}::${reason.message ?? ''}`;
+  }
+  return `UnhandledRejection::${String(reason)}`;
+}
+
+export function installUnhandledRejectionInstrumentation(): () => void {
+  const g = globalThis as unknown as GlobalWithEventTarget;
+  if (typeof g.addEventListener !== 'function' || typeof g.removeEventListener !== 'function') {
+    // Environment doesn't expose a global event target (most bare Node contexts).
+    return () => {};
+  }
+
+  const recentlySeen = new Map<string, number>();
+
+  const handler: RejectionListener = (ev) => {
+    const reason = ev?.reason;
+    const key = dedupeKey(reason);
+    const now = Date.now();
+    const lastAt = recentlySeen.get(key);
+    if (lastAt !== undefined && now - lastAt < DEDUPE_WINDOW_MS) return;
+    recentlySeen.set(key, now);
+
+    if (reason instanceof Error) {
+      Dash0Mobile.log(
+        'app.error',
+        {
+          'exception.type': reason.name ?? 'Error',
+          'exception.message': reason.message ?? String(reason),
+          'exception.stacktrace': reason.stack ?? '',
+          'exception.escaped': true,
+        },
+        SEVERITY_ERROR,
+      );
+    } else {
+      Dash0Mobile.log(
+        'app.error',
+        {
+          'exception.type': 'UnhandledRejection',
+          'exception.message': String(reason),
+          'exception.escaped': true,
+        },
+        SEVERITY_ERROR,
+      );
+    }
+  };
+
+  g.addEventListener('unhandledrejection', handler);
+
+  return function uninstall() {
+    g.removeEventListener?.('unhandledrejection', handler);
+  };
+}

package/src/instrumentation/xhr.ts

@@ -0,0 +1,125 @@
+/**
+ * XMLHttpRequest auto-instrumentation for React Native.
+ *
+ * RN's fetch is itself XHR-backed, so libraries that use XHR directly
+ * (axios, apollo) bypass the fetch wrapper. This module replaces the
+ * global `XMLHttpRequest` constructor with a Proxy that captures a
+ * CLIENT span per request. Attribute shape matches the fetch wrapper so
+ * Dash0 queries see a single consistent HTTP span schema.
+ */
+
+import { Dash0Mobile } from '../index';
+import type { SpanHandle } from '../index';
+
+export interface XhrInstrumentationConfig {
+  ignoredHosts?: readonly string[];
+}
+
+const HOST_PATTERN = /^[a-z][a-z0-9+.-]*:\/\/([^/:?#]+)/i;
+
+function hostFromUrl(url: string): string | null {
+  const match = url.match(HOST_PATTERN);
+  return match ? match[1].toLowerCase() : null;
+}
+
+type XhrCtor = typeof globalThis.XMLHttpRequest;
+
+export function installXhrInstrumentation(
+  config: XhrInstrumentationConfig = {},
+): () => void {
+  const OriginalXHR: XhrCtor | undefined = (
+    globalThis as unknown as { XMLHttpRequest?: XhrCtor }
+  ).XMLHttpRequest;
+
+  if (!OriginalXHR) return () => {};
+
+  const ignored = new Set(
+    (config.ignoredHosts ?? []).map(h => h.toLowerCase()),
+  );
+
+  const wrapped = new Proxy(OriginalXHR, {
+    construct(target, args, newTarget) {
+      const instance = Reflect.construct(target, args, newTarget) as XMLHttpRequest & {
+        __dash0_method?: string;
+        __dash0_url?: string;
+        __dash0_span?: SpanHandle;
+        __dash0_failed?: boolean;
+      };
+
+      const originalOpen = instance.open.bind(instance);
+      (instance as unknown as { open: XMLHttpRequest['open'] }).open = function open(
+        method: string,
+        url: string | URL,
+        ...rest: unknown[]
+      ) {
+        instance.__dash0_method = method.toUpperCase();
+        instance.__dash0_url = typeof url === 'string' ? url : url.toString();
+        // @ts-expect-error — forwarding variadic
+        return originalOpen(method, url, ...rest);
+      };
+
+      const originalSend = instance.send.bind(instance);
+      (instance as unknown as { send: XMLHttpRequest['send'] }).send = function send(
+        body?: Document | XMLHttpRequestBodyInit | null,
+      ) {
+        const url = instance.__dash0_url ?? '';
+        const host = hostFromUrl(url);
+        if (!host || !ignored.has(host)) {
+          const method = instance.__dash0_method ?? 'GET';
+          instance.__dash0_span = Dash0Mobile.startSpan(
+            `${method} ${host ?? 'unknown'}`,
+            {
+              'http.request.method': method,
+              'url.full': url,
+              ...(host ? { 'server.address': host } : {}),
+            },
+            'CLIENT',
+          );
+
+          const onError = () => {
+            instance.__dash0_failed = true;
+          };
+          const onLoadEnd = () => {
+            const span = instance.__dash0_span;
+            if (!span) return;
+            if (instance.__dash0_failed) {
+              span.setStatus('ERROR', 'network error');
+            } else {
+              const status = instance.status;
+              if (typeof status === 'number' && status > 0) {
+                span.setAttribute('http.response.status_code', status);
+                if (status >= 400) {
+                  span.setStatus('ERROR', `HTTP ${status}`);
+                } else {
+                  span.setStatus('OK');
+                }
+              } else {
+                span.setStatus('OK');
+              }
+            }
+            span.end();
+            instance.__dash0_span = undefined;
+          };
+
+          instance.addEventListener('error', onError);
+          instance.addEventListener('loadend', onLoadEnd);
+        }
+        return originalSend(body);
+      };
+
+      return instance;
+    },
+  });
+
+  (globalThis as unknown as { XMLHttpRequest: XhrCtor }).XMLHttpRequest =
+    wrapped as XhrCtor;
+
+  return function uninstall() {
+    const current = (globalThis as unknown as { XMLHttpRequest?: XhrCtor })
+      .XMLHttpRequest;
+    if (current === wrapped) {
+      (globalThis as unknown as { XMLHttpRequest?: XhrCtor }).XMLHttpRequest =
+        OriginalXHR;
+    }
+  };
+}

package/src/otel-compat.ts

@@ -0,0 +1,159 @@
+/**
+ * Minimal @opentelemetry/api compatibility surface.
+ *
+ * Exposes `otel.trace.getTracer`, `otel.logs.getLogger`, `otel.metrics.getMeter`
+ * backed by our bridge. Scope is the subset of the API third-party JS libraries
+ * actually use at runtime — this is NOT a drop-in for the full upstream API.
+ *
+ * Why a shim instead of the real package: adding `@opentelemetry/api` as a
+ * runtime dep pulls version-matching and global-registration concerns into
+ * every RN app that uses us. The shim keeps our bundle small and our bridge
+ * the sole source of truth.
+ */
+
+import { Dash0Mobile } from './index';
+import type { SpanHandle } from './index';
+import type { Attributes, SeverityNumber, SpanKind } from './bridge/types';
+
+// ─── Tracer ──────────────────────────────────────────────────────────────────
+
+interface SpanStatus {
+  code: number; // 0 UNSET, 1 OK, 2 ERROR
+  message?: string;
+}
+
+interface SpanOptions {
+  kind?: number; // OTel SpanKind enum (0-5). We only map 0 INTERNAL / 3 CLIENT / 4 PRODUCER / 5 CONSUMER.
+  attributes?: Attributes;
+}
+
+interface CompatSpan {
+  setAttribute(key: string, value: string | number | boolean): void;
+  setStatus(status: SpanStatus): void;
+  end(): void;
+}
+
+interface CompatTracer {
+  startSpan(name: string, options?: SpanOptions): CompatSpan;
+}
+
+const OTEL_SPAN_KIND_TO_OURS: Record<number, SpanKind> = {
+  0: 'INTERNAL',
+  1: 'SERVER',
+  2: 'CLIENT',
+  3: 'PRODUCER',
+  4: 'CONSUMER',
+};
+
+function mapStatus(code: number): 'OK' | 'ERROR' {
+  return code === 2 ? 'ERROR' : 'OK';
+}
+
+function wrapSpan(handle: SpanHandle): CompatSpan {
+  return {
+    setAttribute(key, value) {
+      handle.setAttribute(key, value);
+    },
+    setStatus(status) {
+      handle.setStatus(mapStatus(status.code), status.message);
+    },
+    end() {
+      handle.end();
+    },
+  };
+}
+
+function getTracer(_name: string, _version?: string): CompatTracer {
+  return {
+    startSpan(name, options) {
+      const kind = OTEL_SPAN_KIND_TO_OURS[options?.kind ?? 0] ?? 'INTERNAL';
+      const handle = Dash0Mobile.startSpan(name, options?.attributes, kind);
+      return wrapSpan(handle);
+    },
+  };
+}
+
+// ─── Logger ──────────────────────────────────────────────────────────────────
+
+interface LogRecord {
+  body?: string;
+  severityNumber?: SeverityNumber;
+  attributes?: Attributes;
+}
+
+interface CompatLogger {
+  emit(record: LogRecord): void;
+}
+
+function getLogger(_name: string, _version?: string): CompatLogger {
+  return {
+    emit(record) {
+      const name = record.body ?? 'log';
+      Dash0Mobile.log(name, record.attributes ?? {}, record.severityNumber ?? 9);
+    },
+  };
+}
+
+// ─── Meter ──────────────────────────────────────────────────────────────────
+
+interface CompatCounter {
+  add(value: number, attributes?: Attributes): void;
+}
+
+interface CompatHistogram {
+  record(value: number, attributes?: Attributes): void;
+}
+
+interface CompatGauge {
+  record(value: number, attributes?: Attributes): void;
+}
+
+interface CompatMeter {
+  createCounter(name: string): CompatCounter;
+  createHistogram(name: string): CompatHistogram;
+  createGauge(name: string): CompatGauge;
+}
+
+function getMeter(_name: string, _version?: string): CompatMeter {
+  return {
+    createCounter(name) {
+      return {
+        add(value, attributes) {
+          Dash0Mobile.recordMetric(name, value, 'counter', attributes ?? {});
+        },
+      };
+    },
+    createHistogram(name) {
+      return {
+        record(value, attributes) {
+          Dash0Mobile.recordMetric(name, value, 'histogram', attributes ?? {});
+        },
+      };
+    },
+    createGauge(name) {
+      return {
+        record(value, attributes) {
+          Dash0Mobile.recordMetric(name, value, 'gauge', attributes ?? {});
+        },
+      };
+    },
+  };
+}
+
+// ─── Namespace ──────────────────────────────────────────────────────────────
+
+export const otel = {
+  trace: { getTracer },
+  logs: { getLogger },
+  metrics: { getMeter },
+};
+
+export type {
+  CompatSpan,
+  CompatTracer,
+  CompatLogger,
+  CompatMeter,
+  CompatCounter,
+  CompatHistogram,
+  CompatGauge,
+};