@barrysolomon/mobile-react-native 0.1.0-alpha

package/lib/src/instrumentation/errors.js

@@ -0,0 +1,65 @@
+/**
+ * Error auto-instrumentation for React Native.
+ *
+ * Chains our handler into RN's `ErrorUtils.setGlobalHandler`, emits an
+ * `app.error` log with OTel `exception.*` semconv attributes, then delegates
+ * to the previous handler so Sentry/Bugsnag/redbox keep working.
+ *
+ * Deduplication: identical (type + message) errors inside a 5-minute window
+ * collapse to a single log, matching the Android ErrorInstrumentation
+ * policy (loops that throw on every frame shouldn't DoS the collector).
+ */
+import { Dash0Mobile } from '../index';
+export const DEDUPE_WINDOW_MS = 5 * 60 * 1000;
+const SEVERITY_ERROR = 17;
+const SEVERITY_FATAL = 21;
+function resolveErrorUtils() {
+    const g = globalThis;
+    return g.ErrorUtils ?? null;
+}
+function dedupeKey(err) {
+    const type = err?.name ?? 'Error';
+    const message = err?.message ?? '';
+    return `${type}::${message}`;
+}
+export function installErrorInstrumentation() {
+    const errorUtils = resolveErrorUtils();
+    if (!errorUtils) {
+        // Non-RN environment — caller is probably in Jest/SSR. Return a no-op
+        // uninstaller so callers don't need to gate on platform.
+        return () => { };
+    }
+    const previous = errorUtils.getGlobalHandler();
+    const recentlySeen = new Map();
+    const handler = (error, isFatal) => {
+        const key = dedupeKey(error);
+        const now = Date.now();
+        const lastAt = recentlySeen.get(key);
+        if (lastAt === undefined || now - lastAt >= DEDUPE_WINDOW_MS) {
+            recentlySeen.set(key, now);
+            Dash0Mobile.log('app.error', {
+                'exception.type': error?.name ?? 'Error',
+                'exception.message': error?.message ?? String(error),
+                'exception.stacktrace': error?.stack ?? '',
+            }, isFatal ? SEVERITY_FATAL : SEVERITY_ERROR);
+        }
+        // Always chain — our capture must never swallow crashes from other
+        // reporters or the default redbox.
+        try {
+            previous(error, isFatal);
+        }
+        catch {
+            // The previous handler throwing would normally be catastrophic, but
+            // we've already emitted the log — nothing safe to do here.
+        }
+    };
+    errorUtils.setGlobalHandler(handler);
+    return function uninstall() {
+        // Best-effort restore. If someone chained on top of us we can't cleanly
+        // unwind — restore `previous` and accept the break (matches how Sentry
+        // handles the same race).
+        if (errorUtils.getGlobalHandler() === handler) {
+            errorUtils.setGlobalHandler(previous);
+        }
+    };
+}

package/lib/src/instrumentation/fetch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * fetch() auto-instrumentation for React Native.
+ *
+ * Wraps the global fetch so every HTTP call produces a CLIENT span with
+ * OTel HTTP semconv v1.23+ attributes. Matches attribute names emitted by
+ * the iOS URLProtocol interceptor and the Android OkHttp interceptor so a
+ * single Dash0 filter surfaces network spans across all three platforms.
+ *
+ * Self-capture avoidance: pass the collector host via `ignoredHosts` so
+ * OTLP export requests don't generate spans that then need to be exported.
+ */
+export interface FetchInstrumentationConfig {
+    ignoredHosts?: readonly string[];
+}
+export declare function installFetchInstrumentation(config?: FetchInstrumentationConfig): () => void;
+//# sourceMappingURL=fetch.d.ts.map

package/lib/src/instrumentation/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../src/instrumentation/fetch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,MAAM,WAAW,0BAA0B;IACzC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAoBD,wBAAgB,2BAA2B,CACzC,MAAM,GAAE,0BAA+B,GACtC,MAAM,IAAI,CAsDZ"}

package/lib/src/instrumentation/fetch.js

@@ -0,0 +1,75 @@
+/**
+ * fetch() auto-instrumentation for React Native.
+ *
+ * Wraps the global fetch so every HTTP call produces a CLIENT span with
+ * OTel HTTP semconv v1.23+ attributes. Matches attribute names emitted by
+ * the iOS URLProtocol interceptor and the Android OkHttp interceptor so a
+ * single Dash0 filter surfaces network spans across all three platforms.
+ *
+ * Self-capture avoidance: pass the collector host via `ignoredHosts` so
+ * OTLP export requests don't generate spans that then need to be exported.
+ */
+import { Dash0Mobile } from '../index';
+function hostFromUrl(url) {
+    const match = /^[a-z][a-z0-9+.-]*:\/\/([^/:?#]+)/i.exec(url);
+    return match ? match[1].toLowerCase() : null;
+}
+function resolveUrl(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof URL)
+        return input.toString();
+    return input.url;
+}
+function resolveMethod(input, init) {
+    const m = init?.method ?? input?.method ?? 'GET';
+    return m.toUpperCase();
+}
+export function installFetchInstrumentation(config = {}) {
+    const original = globalThis.fetch;
+    const ignored = new Set((config.ignoredHosts ?? []).map(h => h.toLowerCase()));
+    const wrapped = async (input, init) => {
+        const url = resolveUrl(input);
+        const host = hostFromUrl(url);
+        if (host && ignored.has(host)) {
+            return original(input, init);
+        }
+        const method = resolveMethod(input, init);
+        const handle = Dash0Mobile.startSpan(method, {
+            'http.request.method': method,
+            'url.full': url,
+            ...(host ? { 'server.address': host } : {}),
+        }, 'CLIENT');
+        try {
+            const response = await original(input, init);
+            const status = response?.status;
+            if (typeof status === 'number') {
+                handle.setAttribute('http.response.status_code', status);
+                if (status >= 400) {
+                    handle.setStatus('ERROR', `HTTP ${status}`);
+                }
+                else {
+                    handle.setStatus('OK');
+                }
+            }
+            else {
+                handle.setStatus('OK');
+            }
+            return response;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            handle.setStatus('ERROR', message);
+            throw err;
+        }
+        finally {
+            handle.end();
+        }
+    };
+    globalThis.fetch = wrapped;
+    return function uninstall() {
+        if (globalThis.fetch === wrapped) {
+            globalThis.fetch = original;
+        }
+    };
+}

package/lib/src/instrumentation/navigation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * React Navigation auto-instrumentation (opt-in).
+ *
+ * Usage:
+ *   const navRef = useNavigationContainerRef();
+ *   useEffect(() => installReactNavigationInstrumentation(navRef), [navRef]);
+ *
+ * Emits `ui.screen_view` logs and `page.<name>` spans keyed by the current
+ * route. Consecutive emissions for the same route are suppressed.
+ */
+interface NavRefLike {
+    addListener(type: string, listener: () => void): () => void;
+    getCurrentRoute(): {
+        name: string;
+    } | undefined;
+}
+export declare function installReactNavigationInstrumentation(navRef: NavRefLike | null | undefined): () => void;
+export {};
+//# sourceMappingURL=navigation.d.ts.map

package/lib/src/instrumentation/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/instrumentation/navigation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,UAAU,UAAU;IAClB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5D,eAAe,IAAI;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CACjD;AAED,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACpC,MAAM,IAAI,CA8BZ"}

package/lib/src/instrumentation/navigation.js

@@ -0,0 +1,39 @@
+/**
+ * React Navigation auto-instrumentation (opt-in).
+ *
+ * Usage:
+ *   const navRef = useNavigationContainerRef();
+ *   useEffect(() => installReactNavigationInstrumentation(navRef), [navRef]);
+ *
+ * Emits `ui.screen_view` logs and `page.<name>` spans keyed by the current
+ * route. Consecutive emissions for the same route are suppressed.
+ */
+import { Dash0Mobile } from '../index';
+export function installReactNavigationInstrumentation(navRef) {
+    if (!navRef)
+        return () => { };
+    let currentName = null;
+    let currentSpan = null;
+    const onState = () => {
+        const route = navRef.getCurrentRoute();
+        if (!route)
+            return;
+        if (route.name === currentName)
+            return;
+        if (currentSpan) {
+            currentSpan.end();
+            currentSpan = null;
+        }
+        currentName = route.name;
+        Dash0Mobile.log('ui.screen_view', { 'screen.name': route.name }, 9);
+        currentSpan = Dash0Mobile.startSpan(`page.${route.name}`);
+    };
+    const unsub = navRef.addListener('state', onState);
+    return function uninstall() {
+        unsub();
+        if (currentSpan) {
+            currentSpan.end();
+            currentSpan = null;
+        }
+    };
+}

package/lib/src/instrumentation/touch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 type { Attributes } from '../bridge/types';
+type Handler<Args extends unknown[], R> = (...args: Args) => R;
+export declare function withTapTelemetry<Args extends unknown[], R>(target: string, handler?: Handler<Args, R>, extraAttrs?: Attributes): Handler<Args, R | undefined>;
+export {};
+//# sourceMappingURL=touch.d.ts.map

package/lib/src/instrumentation/touch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch.d.ts","sourceRoot":"","sources":["../../../src/instrumentation/touch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIlD,KAAK,OAAO,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,CAAC;AAE/D,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EACxD,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,EAC1B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAY9B"}

package/lib/src/instrumentation/touch.js

@@ -0,0 +1,18 @@
+/**
+ * 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';
+const SEVERITY_INFO = 9;
+export function withTapTelemetry(target, handler, extraAttrs) {
+    return function wrappedOnPress(...args) {
+        Dash0Mobile.log('ui.tap', {
+            'ui.target': target,
+            ...(extraAttrs ?? {}),
+        }, SEVERITY_INFO);
+        return handler ? handler(...args) : undefined;
+    };
+}

package/lib/src/instrumentation/unhandledRejection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function installUnhandledRejectionInstrumentation(): () => void;
+//# sourceMappingURL=unhandledRejection.d.ts.map

package/lib/src/instrumentation/unhandledRejection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unhandledRejection.d.ts","sourceRoot":"","sources":["../../../src/instrumentation/unhandledRejection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsBH,wBAAgB,wCAAwC,IAAI,MAAM,IAAI,CA8CrE"}

package/lib/src/instrumentation/unhandledRejection.js

@@ -0,0 +1,52 @@
+/**
+ * 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;
+function dedupeKey(reason) {
+    if (reason instanceof Error) {
+        return `${reason.name ?? 'Error'}::${reason.message ?? ''}`;
+    }
+    return `UnhandledRejection::${String(reason)}`;
+}
+export function installUnhandledRejectionInstrumentation() {
+    const g = globalThis;
+    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();
+    const handler = (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/lib/src/instrumentation/xhr.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export interface XhrInstrumentationConfig {
+    ignoredHosts?: readonly string[];
+}
+export declare function installXhrInstrumentation(config?: XhrInstrumentationConfig): () => void;
+//# sourceMappingURL=xhr.d.ts.map

package/lib/src/instrumentation/xhr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr.d.ts","sourceRoot":"","sources":["../../../src/instrumentation/xhr.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,WAAW,wBAAwB;IACvC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAWD,wBAAgB,yBAAyB,CACvC,MAAM,GAAE,wBAA6B,GACpC,MAAM,IAAI,CAgGZ"}

package/lib/src/instrumentation/xhr.js

@@ -0,0 +1,88 @@
+/**
+ * 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';
+const HOST_PATTERN = /^[a-z][a-z0-9+.-]*:\/\/([^/:?#]+)/i;
+function hostFromUrl(url) {
+    const match = url.match(HOST_PATTERN);
+    return match ? match[1].toLowerCase() : null;
+}
+export function installXhrInstrumentation(config = {}) {
+    const OriginalXHR = globalThis.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);
+            const originalOpen = instance.open.bind(instance);
+            instance.open = function open(method, url, ...rest) {
+                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.send = function send(body) {
+                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.XMLHttpRequest =
+        wrapped;
+    return function uninstall() {
+        const current = globalThis
+            .XMLHttpRequest;
+        if (current === wrapped) {
+            globalThis.XMLHttpRequest =
+                OriginalXHR;
+        }
+    };
+}

package/lib/src/otel-compat.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 type { Attributes, SeverityNumber } from './bridge/types';
+interface SpanStatus {
+    code: number;
+    message?: string;
+}
+interface SpanOptions {
+    kind?: number;
+    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;
+}
+declare function getTracer(_name: string, _version?: string): CompatTracer;
+interface LogRecord {
+    body?: string;
+    severityNumber?: SeverityNumber;
+    attributes?: Attributes;
+}
+interface CompatLogger {
+    emit(record: LogRecord): void;
+}
+declare function getLogger(_name: string, _version?: string): CompatLogger;
+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;
+}
+declare function getMeter(_name: string, _version?: string): CompatMeter;
+export declare const otel: {
+    trace: {
+        getTracer: typeof getTracer;
+    };
+    logs: {
+        getLogger: typeof getLogger;
+    };
+    metrics: {
+        getMeter: typeof getMeter;
+    };
+};
+export type { CompatSpan, CompatTracer, CompatLogger, CompatMeter, CompatCounter, CompatHistogram, CompatGauge, };
+//# sourceMappingURL=otel-compat.d.ts.map

package/lib/src/otel-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-compat.d.ts","sourceRoot":"","sources":["../../src/otel-compat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAY,MAAM,gBAAgB,CAAC;AAI3E,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,WAAW;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,UAAU,UAAU;IAClB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAClE,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACpC,GAAG,IAAI,IAAI,CAAC;CACb;AAED,UAAU,YAAY;IACpB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;CAC5D;AA4BD,iBAAS,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAQjE;AAID,UAAU,SAAS;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,UAAU,YAAY;IACpB,IAAI,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC/B;AAED,iBAAS,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAOjE;AAID,UAAU,aAAa;IACrB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CACnD;AAED,UAAU,eAAe;IACvB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CACtD;AAED,UAAU,WAAW;IACnB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CACtD;AAED,UAAU,WAAW;IACnB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC;IAC3C,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC;IAC/C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CACxC;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,CAwB/D;AAID,eAAO,MAAM,IAAI;;;;;;;;;;CAIhB,CAAC;AAEF,YAAY,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,eAAe,EACf,WAAW,GACZ,CAAC"}

package/lib/src/otel-compat.js

@@ -0,0 +1,84 @@
+/**
+ * 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';
+const OTEL_SPAN_KIND_TO_OURS = {
+    0: 'INTERNAL',
+    1: 'SERVER',
+    2: 'CLIENT',
+    3: 'PRODUCER',
+    4: 'CONSUMER',
+};
+function mapStatus(code) {
+    return code === 2 ? 'ERROR' : 'OK';
+}
+function wrapSpan(handle) {
+    return {
+        setAttribute(key, value) {
+            handle.setAttribute(key, value);
+        },
+        setStatus(status) {
+            handle.setStatus(mapStatus(status.code), status.message);
+        },
+        end() {
+            handle.end();
+        },
+    };
+}
+function getTracer(_name, _version) {
+    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);
+        },
+    };
+}
+function getLogger(_name, _version) {
+    return {
+        emit(record) {
+            const name = record.body ?? 'log';
+            Dash0Mobile.log(name, record.attributes ?? {}, record.severityNumber ?? 9);
+        },
+    };
+}
+function getMeter(_name, _version) {
+    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 },
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@barrysolomon/mobile-react-native",
+  "version": "0.1.0-alpha",
+  "description": "Dash0 Mobile Observability SDK for React Native (JS/TS bridge). For native iOS use the Swift Package at https://github.com/barrysolomon/mobile-otel. For native Android use io.opentelemetry.android:mobile on GitHub Packages.",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/src/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!**/__tests__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "publish:alpha": "npm publish --tag alpha"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "react-native",
+    "opentelemetry",
+    "observability",
+    "dash0",
+    "mobile",
+    "rum"
+  ],
+  "repository": "https://github.com/barrysolomon/mobile-otel",
+  "license": "Apache-2.0",
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.73.0",
+    "jest": "^29.7.0",
+    "react": "18.3.1",
+    "react-native": "0.76.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/__tests__/**/*.test.(ts|tsx)"
+    ],
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json"
+    ]
+  }
+}