react-native-otel 0.1.0

package/src/core/meter.ts

@@ -0,0 +1,82 @@
+import type { Attributes } from './attributes';
+import type { MetricExporter, MetricRecord } from '../exporters/types';
+import { sanitizeAttributes } from './attributes';
+import { now } from './clock';
+
+export class Counter {
+  constructor(
+    private name: string,
+    private pushToBuffer: (record: MetricRecord) => void
+  ) {}
+
+  add(value: number, attrs?: Attributes): void {
+    this.pushToBuffer({
+      type: 'counter',
+      name: this.name,
+      value,
+      timestampMs: now(),
+      attributes: attrs ? sanitizeAttributes(attrs) : {},
+    });
+  }
+}
+
+export class Histogram {
+  constructor(
+    private name: string,
+    private pushToBuffer: (record: MetricRecord) => void
+  ) {}
+
+  record(value: number, attrs?: Attributes): void {
+    this.pushToBuffer({
+      type: 'histogram',
+      name: this.name,
+      value,
+      timestampMs: now(),
+      attributes: attrs ? sanitizeAttributes(attrs) : {},
+    });
+  }
+}
+
+export class Gauge {
+  constructor(
+    private name: string,
+    private pushToBuffer: (record: MetricRecord) => void
+  ) {}
+
+  set(value: number, attrs?: Attributes): void {
+    this.pushToBuffer({
+      type: 'gauge',
+      name: this.name,
+      value,
+      timestampMs: now(),
+      attributes: attrs ? sanitizeAttributes(attrs) : {},
+    });
+  }
+}
+
+export class Meter {
+  private buffer: MetricRecord[] = [];
+  private exporter: MetricExporter | undefined;
+
+  constructor(exporter?: MetricExporter) {
+    this.exporter = exporter;
+  }
+
+  createCounter(name: string): Counter {
+    return new Counter(name, (r) => this.buffer.push(r));
+  }
+
+  createHistogram(name: string): Histogram {
+    return new Histogram(name, (r) => this.buffer.push(r));
+  }
+
+  createGauge(name: string): Gauge {
+    return new Gauge(name, (r) => this.buffer.push(r));
+  }
+
+  flush(): void {
+    if (this.buffer.length === 0) return;
+    const toExport = this.buffer.splice(0, this.buffer.length);
+    this.exporter?.export(toExport);
+  }
+}

package/src/core/resource.ts

@@ -0,0 +1,50 @@
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} from '@opentelemetry/semantic-conventions';
+import {
+  ATTR_APP_BUILD_ID,
+  ATTR_DEPLOYMENT_ENVIRONMENT_NAME,
+  ATTR_DEVICE_MANUFACTURER,
+  ATTR_DEVICE_MODEL_NAME,
+  ATTR_OS_NAME,
+  ATTR_OS_VERSION,
+} from '@opentelemetry/semantic-conventions/incubating';
+
+export interface Resource {
+  [ATTR_SERVICE_NAME]: string; // 'service.name'
+  [ATTR_SERVICE_VERSION]: string; // 'service.version'
+  [ATTR_OS_NAME]: string; // 'os.name'
+  [ATTR_OS_VERSION]: string; // 'os.version'
+  [ATTR_DEVICE_MANUFACTURER]: string; // 'device.manufacturer'
+  [ATTR_DEVICE_MODEL_NAME]: string; // 'device.model.name'
+  'device.type': string | number; // custom — no OTel equivalent
+  [ATTR_APP_BUILD_ID]: string; // 'app.build_id'
+  [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: string; // 'deployment.environment.name'
+}
+
+// Populated at init time from device/app info passed in by the caller.
+// Immutable after creation — user identity is NOT stored here.
+export function buildResource(params: {
+  serviceName: string;
+  serviceVersion: string;
+  osName: string;
+  osVersion: string;
+  deviceBrand: string;
+  deviceModel: string;
+  deviceType: string | number;
+  appBuild: string;
+  environment: string;
+}): Readonly<Resource> {
+  return Object.freeze({
+    [ATTR_SERVICE_NAME]: params.serviceName,
+    [ATTR_SERVICE_VERSION]: params.serviceVersion,
+    [ATTR_OS_NAME]: params.osName,
+    [ATTR_OS_VERSION]: params.osVersion,
+    [ATTR_DEVICE_MANUFACTURER]: params.deviceBrand,
+    [ATTR_DEVICE_MODEL_NAME]: params.deviceModel,
+    'device.type': params.deviceType,
+    [ATTR_APP_BUILD_ID]: params.appBuild,
+    [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: params.environment,
+  });
+}

package/src/core/span.ts

@@ -0,0 +1,161 @@
+import {
+  ATTR_EXCEPTION_MESSAGE,
+  ATTR_EXCEPTION_STACKTRACE,
+  ATTR_EXCEPTION_TYPE,
+} from '@opentelemetry/semantic-conventions';
+
+import type { Attributes } from './attributes';
+import { sanitizeAttributes, sanitizeValue } from './attributes';
+import { now } from './clock';
+import { generateSpanId, generateTraceId } from './ids';
+
+// Defined here to avoid circular dep with exporters/types.ts
+export interface SpanExporter {
+  export(spans: ReadonlySpan[]): void;
+}
+
+export type SpanKind =
+  | 'INTERNAL'
+  | 'CLIENT'
+  | 'SERVER'
+  | 'PRODUCER'
+  | 'CONSUMER';
+export type SpanStatus = 'UNSET' | 'OK' | 'ERROR';
+
+export interface SpanEvent {
+  name: string;
+  timestampMs: number;
+  attributes: Attributes;
+}
+
+export interface ReadonlySpan {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId: string | undefined;
+  readonly name: string;
+  readonly kind: SpanKind;
+  readonly startTimeMs: number;
+  readonly endTimeMs: number | undefined;
+  readonly attributes: Readonly<Attributes>;
+  readonly events: readonly SpanEvent[];
+  readonly droppedEventsCount: number;
+  readonly status: SpanStatus;
+  readonly statusMessage: string | undefined;
+}
+
+// Carries both IDs needed to link a child span into an existing trace.
+export interface SpanContext {
+  traceId: string;
+  spanId: string;
+}
+
+export class Span implements ReadonlySpan {
+  private static readonly MAX_EVENTS = 128;
+
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId: string | undefined;
+  readonly name: string;
+  readonly kind: SpanKind;
+  readonly startTimeMs: number;
+
+  endTimeMs: number | undefined = undefined;
+  // Mutable plain object — setAttribute writes directly, no full clone.
+  attributes: Attributes;
+  events: SpanEvent[] = [];
+  droppedEventsCount = 0;
+  status: SpanStatus = 'UNSET';
+  statusMessage: string | undefined = undefined;
+
+  private exporter: SpanExporter | undefined;
+
+  constructor(params: {
+    name: string;
+    kind?: SpanKind;
+    attributes?: Attributes;
+    // Pass the full parent context so the child inherits the same traceId.
+    parent?: SpanContext;
+    exporter?: SpanExporter;
+  }) {
+    this.traceId = params.parent?.traceId ?? generateTraceId();
+    this.spanId = generateSpanId();
+    this.parentSpanId = params.parent?.spanId;
+    this.name = params.name;
+    this.kind = params.kind ?? 'INTERNAL';
+    this.startTimeMs = now();
+    this.attributes = params.attributes
+      ? sanitizeAttributes(params.attributes)
+      : {};
+    this.exporter = params.exporter;
+  }
+
+  setAttribute(key: string, value: Attributes[string]): void {
+    if (this.endTimeMs !== undefined) return;
+    // sanitizeValue handles one value — no object clone needed.
+    const sanitized = sanitizeValue(value);
+    if (sanitized !== undefined) {
+      this.attributes[key] = sanitized;
+    }
+  }
+
+  addEvent(name: string, attrs?: Attributes): void {
+    if (this.endTimeMs !== undefined) return;
+    if (this.events.length >= Span.MAX_EVENTS) {
+      this.droppedEventsCount++;
+      return;
+    }
+    this.events.push({
+      name,
+      timestampMs: now(),
+      attributes: attrs ? sanitizeAttributes(attrs) : {},
+    });
+  }
+
+  setStatus(status: SpanStatus, message?: string): void {
+    if (this.endTimeMs !== undefined) return;
+    this.status = status;
+    this.statusMessage = message;
+  }
+
+  recordException(error: Error, attrs?: Attributes): void {
+    this.addEvent('exception', {
+      [ATTR_EXCEPTION_TYPE]: error.name,
+      [ATTR_EXCEPTION_MESSAGE]: error.message,
+      [ATTR_EXCEPTION_STACKTRACE]: error.stack ?? '',
+      ...attrs,
+    });
+    this.setStatus('ERROR', error.message);
+  }
+
+  end(): void {
+    if (this.endTimeMs !== undefined) return;
+    this.endTimeMs = now();
+    if (this.status === 'UNSET') {
+      this.status = 'OK';
+    }
+    this.exporter?.export([this]);
+  }
+}
+
+// No-op span used when sampling drops a span.
+// Implements the same interface so callers never null-check.
+export class NoopSpan implements ReadonlySpan {
+  readonly traceId = '';
+  readonly spanId = '';
+  readonly parentSpanId = undefined;
+  readonly name = '';
+  readonly kind: SpanKind = 'INTERNAL';
+  readonly startTimeMs = 0;
+  readonly endTimeMs = undefined;
+  readonly attributes = {};
+  readonly events: SpanEvent[] = [];
+  readonly droppedEventsCount = 0;
+  readonly status: SpanStatus = 'UNSET';
+  readonly statusMessage = undefined;
+
+  setAttribute(_key: string, _value: Attributes[string]): void {}
+  addEvent(_name: string, _attrs?: Attributes): void {}
+  setStatus(_status: SpanStatus, _message?: string): void {}
+  recordException(_error: Error, _attrs?: Attributes): void {}
+  end(): void {}
+}

package/src/core/tracer.ts

@@ -0,0 +1,75 @@
+import {
+  ATTR_EXCEPTION_MESSAGE,
+  ATTR_EXCEPTION_STACKTRACE,
+  ATTR_EXCEPTION_TYPE,
+} from '@opentelemetry/semantic-conventions';
+
+import type { Attributes } from './attributes';
+import type { SpanContext, SpanExporter, SpanKind } from './span';
+import { Span, NoopSpan } from './span';
+import { spanContext } from '../context/span-context';
+
+export class Tracer {
+  private exporter: SpanExporter | undefined;
+  private sampleRate: number;
+  private getUserAttributes: () => Attributes;
+
+  constructor(params: {
+    exporter?: SpanExporter;
+    sampleRate?: number;
+    getUserAttributes: () => Attributes;
+  }) {
+    this.exporter = params.exporter;
+    this.sampleRate = params.sampleRate ?? 1.0;
+    this.getUserAttributes = params.getUserAttributes;
+  }
+
+  startSpan(
+    name: string,
+    options?: {
+      kind?: SpanKind;
+      attributes?: Attributes;
+      // Pass the full parent context to inherit traceId.
+      // If omitted, the current screen span is used automatically.
+      // Pass null explicitly to force a new root trace.
+      parent?: SpanContext | null;
+    }
+  ): Span | NoopSpan {
+    if (this.sampleRate < 1.0 && Math.random() > this.sampleRate) {
+      return new NoopSpan();
+    }
+
+    // Resolve parent: explicit > current screen span > none (new trace)
+    const parent: SpanContext | undefined =
+      options?.parent !== undefined
+        ? options.parent ?? undefined
+        : spanContext.current() ?? undefined;
+
+    const userAttrs = this.getUserAttributes();
+    return new Span({
+      name,
+      kind: options?.kind,
+      attributes: { ...userAttrs, ...options?.attributes },
+      parent,
+      exporter: this.exporter,
+    });
+  }
+
+  recordEvent(name: string, attributes?: Attributes): void {
+    spanContext.current()?.addEvent(name, attributes);
+  }
+
+  recordException(error: Error, attributes?: Attributes): void {
+    const span = this.startSpan(`exception.${error.name}`, {
+      kind: 'INTERNAL',
+      attributes: {
+        [ATTR_EXCEPTION_TYPE]: error.name,
+        [ATTR_EXCEPTION_MESSAGE]: error.message,
+        [ATTR_EXCEPTION_STACKTRACE]: error.stack ?? '',
+        ...attributes,
+      },
+    });
+    span.setStatus('ERROR', error.message);
+    span.end();
+  }
+}

package/src/exporters/console-exporter.ts

@@ -0,0 +1,89 @@
+import type {
+  SpanExporter,
+  MetricExporter,
+  LogExporter,
+  ReadonlySpan,
+  MetricRecord,
+  LogRecord,
+} from './types';
+
+function shouldLog(debug: boolean): boolean {
+  return debug || process.env.NODE_ENV === 'development';
+}
+
+export class ConsoleSpanExporter implements SpanExporter {
+  constructor(private debug = false) {}
+
+  export(spans: ReadonlySpan[]): void {
+    if (!shouldLog(this.debug)) return;
+
+    for (const span of spans) {
+      const duration =
+        span.endTimeMs !== undefined
+          ? `${span.endTimeMs - span.startTimeMs}ms`
+          : 'ongoing';
+      const lines: string[] = [
+        `[OTEL SPAN] ${span.name} (traceId=${span.traceId} spanId=${
+          span.spanId
+        })${span.parentSpanId ? ` parentSpanId=${span.parentSpanId}` : ''}`,
+        `  duration: ${duration}  status: ${span.status}${
+          span.statusMessage ? ` (${span.statusMessage})` : ''
+        }`,
+        `  attributes: ${JSON.stringify(span.attributes)}`,
+      ];
+
+      if (span.events.length > 0) {
+        lines.push('  events:');
+        for (const event of span.events) {
+          const offset = event.timestampMs - span.startTimeMs;
+          const attrsStr =
+            Object.keys(event.attributes).length > 0
+              ? `  ${JSON.stringify(event.attributes)}`
+              : '{}';
+          lines.push(`    [+${offset}ms]  ${event.name}  ${attrsStr}`);
+        }
+      }
+
+      if (span.droppedEventsCount > 0) {
+        lines.push(`  dropped_events: ${span.droppedEventsCount}`);
+      }
+
+      console.log(lines.join('\n'));
+    }
+  }
+}
+
+export class ConsoleMetricExporter implements MetricExporter {
+  constructor(private debug = false) {}
+
+  export(metrics: MetricRecord[]): void {
+    if (!shouldLog(this.debug)) return;
+
+    for (const metric of metrics) {
+      console.log(
+        `[OTEL METRIC] ${metric.name} ${metric.type} value=${metric.value}`,
+        Object.keys(metric.attributes).length > 0 ? metric.attributes : ''
+      );
+    }
+  }
+}
+
+export class ConsoleLogExporter implements LogExporter {
+  constructor(private debug = false) {}
+
+  export(logs: LogRecord[]): void {
+    if (!shouldLog(this.debug)) return;
+
+    for (const log of logs) {
+      const traceInfo = log.traceId
+        ? `{ trace: ${log.traceId}, span: ${log.spanId} }`
+        : '';
+
+      console.log(
+        `[OTEL LOG] ${log.severity.padEnd(5)}  ${log.body}`,
+        traceInfo,
+        Object.keys(log.attributes).length > 0 ? log.attributes : ''
+      );
+    }
+  }
+}