@reliantlabs/forge-web-runtime 0.10.0 → 0.10.2

package/dist/node-otlp.js

@@ -0,0 +1,235 @@
+// Part of @reliantlabs/forge-web-runtime — the web twin of forge/pkg.
+//
+// OTLP/HTTP with JSON bodies, for the `/node` entry: the encoding, the
+// exporter and the batching queue. Node built-ins only (global fetch,
+// timers), so it runs unchanged under Electron's main process.
+//
+// ── Why not the OpenTelemetry JS SDK ─────────────────────────────────────
+//
+// The SDK would be six more peer packages (sdk-logs, sdk-trace, resources,
+// two exporters, context-async-hooks) whose major lines move together and
+// fast — 3.0 landed with a new package layout and a hard @opentelemetry/api
+// 1.10 floor. Every consumer of this package would have to match that set
+// exactly. What `/node` needs from it is small and stable: the OTLP/JSON wire
+// format (OTLP 1.x, frozen), a batch, a flush. So it is written here, against
+// the wire format, and the only OpenTelemetry package involved is the
+// @opentelemetry/api this runtime already peers on.
+//
+// ── The wire format ──────────────────────────────────────────────────────
+//
+// OTLP/JSON differs from the protobuf JSON mapping in two places that matter:
+// traceId and spanId are lowercase HEX (not base64), and enum fields are
+// integers. 64-bit integers (timestamps, intValue) are decimal strings.
+/** Most attributes on one record or span; the rest are dropped. */
+export const MAX_ATTRIBUTES = 128;
+/** Longest string attribute value. */
+export const MAX_ATTRIBUTE_CHARS = 4096;
+function scalar(v) {
+    switch (typeof v) {
+        case "string":
+            return {
+                stringValue: v.length > MAX_ATTRIBUTE_CHARS ? v.slice(0, MAX_ATTRIBUTE_CHARS) : v,
+            };
+        case "boolean":
+            return { boolValue: v };
+        case "number":
+            if (!Number.isFinite(v)) {
+                return null;
+            }
+            return Number.isSafeInteger(v)
+                ? { intValue: String(v) }
+                : { doubleValue: v };
+        default:
+            return null;
+    }
+}
+/** OTLP KeyValues for `attrs`: bounded, unencodable values dropped. */
+export function encodeAttributes(attrs) {
+    const out = [];
+    if (!attrs) {
+        return out;
+    }
+    for (const [key, v] of Object.entries(attrs)) {
+        if (out.length >= MAX_ATTRIBUTES) {
+            break;
+        }
+        if (v === undefined) {
+            continue;
+        }
+        if (Array.isArray(v)) {
+            const values = v.map(scalar).filter((x) => x !== null);
+            out.push({ key, value: { arrayValue: { values } } });
+            continue;
+        }
+        const value = scalar(v);
+        if (value) {
+            out.push({ key, value });
+        }
+    }
+    return out;
+}
+/** Nanoseconds since the epoch for `ms` (fractional ms allowed), as OTLP's decimal string. */
+export function unixNanos(ms) {
+    const whole = Math.floor(ms);
+    const frac = Math.round((ms - whole) * 1e6);
+    return (BigInt(whole) * 1000000n + BigInt(frac)).toString();
+}
+/** Now, in epoch milliseconds with sub-millisecond precision. */
+export function nowMs() {
+    return performance.timeOrigin + performance.now();
+}
+/** OTel severity numbers (logs data model). */
+export const SEVERITY = {
+    DEBUG: 5,
+    INFO: 9,
+    WARN: 13,
+    ERROR: 17,
+};
+/** The ExportLogsServiceRequest body for one batch. */
+export function logsPayload(resource, scope, records) {
+    return {
+        resourceLogs: [
+            {
+                resource: { attributes: resource },
+                scopeLogs: [{ scope, logRecords: records }],
+            },
+        ],
+    };
+}
+/** The ExportTraceServiceRequest body for one batch, spans grouped by scope. */
+export function tracesPayload(resource, spans) {
+    const byScope = new Map();
+    for (const { scope, ...span } of spans) {
+        const key = `${scope.name}\u001f${scope.version ?? ""}`;
+        let group = byScope.get(key);
+        if (!group) {
+            group = { scope, spans: [] };
+            byScope.set(key, group);
+        }
+        group.spans.push(span);
+    }
+    return {
+        resourceSpans: [
+            {
+                resource: { attributes: resource },
+                scopeSpans: [...byScope.values()],
+            },
+        ],
+    };
+}
+/** Longest backoff between attempts, whatever Retry-After asks for. */
+export const MAX_RETRY_DELAY_MS = 5_000;
+const RETRYABLE = new Set([429, 502, 503, 504]);
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        const t = setTimeout(resolve, ms);
+        t.unref?.();
+    });
+}
+function retryDelay(attempt, retryAfter) {
+    const seconds = retryAfter === null ? NaN : Number(retryAfter);
+    const base = Number.isFinite(seconds) && seconds >= 0
+        ? seconds * 1000
+        : 250 * 2 ** attempt;
+    return Math.min(MAX_RETRY_DELAY_MS, base);
+}
+/**
+ * Posts one OTLP/JSON body to `${endpoint}/v1/<signal>`. Resolves true when
+ * the collector accepted it, false when it was dropped (after the retries);
+ * never rejects.
+ */
+export async function exportSignal(opts, signal, body) {
+    const url = `${opts.endpoint}/v1/${signal}`;
+    const payload = JSON.stringify(body);
+    const sleep = opts.sleep ?? defaultSleep;
+    let last = null;
+    for (let attempt = 0; attempt <= opts.retries; attempt++) {
+        let retryAfter = null;
+        try {
+            const res = await opts.fetch(url, {
+                method: "POST",
+                headers: { ...opts.headers, "content-type": "application/json" },
+                body: payload,
+                signal: AbortSignal.timeout(opts.timeoutMs),
+            });
+            if (res.status >= 200 && res.status < 300) {
+                return true;
+            }
+            last = new Error(`OTLP ${signal} export: HTTP ${res.status}`);
+            if (!RETRYABLE.has(res.status)) {
+                break;
+            }
+            retryAfter = res.headers.get("retry-after");
+        }
+        catch (err) {
+            last = err instanceof Error ? err : new Error(String(err));
+        }
+        if (attempt < opts.retries) {
+            await sleep(retryDelay(attempt, retryAfter));
+        }
+    }
+    try {
+        opts.onError?.(last ?? new Error(`OTLP ${signal} export failed`));
+    }
+    catch {
+        // A diagnostics hook must not break telemetry.
+    }
+    return false;
+}
+/**
+ * A bounded queue that exports in batches: when a batch fills, when the delay
+ * after the first queued item elapses, or on flush(). Its timer is unref'd, so
+ * a pending batch never keeps a process alive by itself.
+ */
+export class BatchQueue {
+    opts;
+    items = [];
+    timer = null;
+    inflight = new Set();
+    /** Items refused because the queue was full. */
+    dropped = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get size() {
+        return this.items.length;
+    }
+    push(item) {
+        if (this.items.length >= this.opts.maxQueue) {
+            this.dropped++;
+            return;
+        }
+        this.items.push(item);
+        if (this.items.length >= this.opts.maxBatch) {
+            this.drain();
+        }
+        else if (!this.timer) {
+            this.timer = setTimeout(() => {
+                this.timer = null;
+                this.drain();
+            }, this.opts.delayMs);
+            this.timer.unref?.();
+        }
+    }
+    /** Start exporting everything queued now, without waiting for it. */
+    drain() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        while (this.items.length > 0) {
+            const batch = this.items.splice(0, this.opts.maxBatch);
+            const p = this.opts.send(batch).catch(() => undefined);
+            this.inflight.add(p);
+            void p.finally(() => this.inflight.delete(p));
+        }
+    }
+    /** Export everything queued and wait for every export in flight. */
+    async flush() {
+        this.drain();
+        while (this.inflight.size > 0) {
+            await Promise.all([...this.inflight]);
+        }
+    }
+}
+//# sourceMappingURL=node-otlp.js.map

package/dist/node-otlp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-otlp.js","sourceRoot":"","sources":["../src/node-otlp.ts"],"names":[],"mappings":"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","sourcesContent":["// Part of @reliantlabs/forge-web-runtime — the web twin of forge/pkg.\n//\n// OTLP/HTTP with JSON bodies, for the `/node` entry: the encoding, the\n// exporter and the batching queue. Node built-ins only (global fetch,\n// timers), so it runs unchanged under Electron's main process.\n//\n// ── Why not the OpenTelemetry JS SDK ─────────────────────────────────────\n//\n// The SDK would be six more peer packages (sdk-logs, sdk-trace, resources,\n// two exporters, context-async-hooks) whose major lines move together and\n// fast — 3.0 landed with a new package layout and a hard @opentelemetry/api\n// 1.10 floor. Every consumer of this package would have to match that set\n// exactly. What `/node` needs from it is small and stable: the OTLP/JSON wire\n// format (OTLP 1.x, frozen), a batch, a flush. So it is written here, against\n// the wire format, and the only OpenTelemetry package involved is the\n// @opentelemetry/api this runtime already peers on.\n//\n// ── The wire format ──────────────────────────────────────────────────────\n//\n// OTLP/JSON differs from the protobuf JSON mapping in two places that matter:\n// traceId and spanId are lowercase HEX (not base64), and enum fields are\n// integers. 64-bit integers (timestamps, intValue) are decimal strings.\n\n/** An attribute value a record or span may carry. */\nexport type AttributeValue =\n  | string\n  | number\n  | boolean\n  | ReadonlyArray<string>\n  | ReadonlyArray<number>\n  | ReadonlyArray<boolean>;\nexport type Attributes = Record<string, AttributeValue | undefined>;\n\n/** Most attributes on one record or span; the rest are dropped. */\nexport const MAX_ATTRIBUTES = 128;\n/** Longest string attribute value. */\nexport const MAX_ATTRIBUTE_CHARS = 4096;\n\ninterface AnyValue {\n  stringValue?: string;\n  boolValue?: boolean;\n  intValue?: string;\n  doubleValue?: number;\n  arrayValue?: { values: AnyValue[] };\n}\n\nexport interface KeyValue {\n  key: string;\n  value: AnyValue;\n}\n\nfunction scalar(v: unknown): AnyValue | null {\n  switch (typeof v) {\n    case \"string\":\n      return {\n        stringValue:\n          v.length > MAX_ATTRIBUTE_CHARS ? v.slice(0, MAX_ATTRIBUTE_CHARS) : v,\n      };\n    case \"boolean\":\n      return { boolValue: v };\n    case \"number\":\n      if (!Number.isFinite(v)) {\n        return null;\n      }\n      return Number.isSafeInteger(v)\n        ? { intValue: String(v) }\n        : { doubleValue: v };\n    default:\n      return null;\n  }\n}\n\n/** OTLP KeyValues for `attrs`: bounded, unencodable values dropped. */\nexport function encodeAttributes(attrs: Attributes | undefined): KeyValue[] {\n  const out: KeyValue[] = [];\n  if (!attrs) {\n    return out;\n  }\n  for (const [key, v] of Object.entries(attrs)) {\n    if (out.length >= MAX_ATTRIBUTES) {\n      break;\n    }\n    if (v === undefined) {\n      continue;\n    }\n    if (Array.isArray(v)) {\n      const values = v.map(scalar).filter((x): x is AnyValue => x !== null);\n      out.push({ key, value: { arrayValue: { values } } });\n      continue;\n    }\n    const value = scalar(v);\n    if (value) {\n      out.push({ key, value });\n    }\n  }\n  return out;\n}\n\n/** Nanoseconds since the epoch for `ms` (fractional ms allowed), as OTLP's decimal string. */\nexport function unixNanos(ms: number): string {\n  const whole = Math.floor(ms);\n  const frac = Math.round((ms - whole) * 1e6);\n  return (BigInt(whole) * 1_000_000n + BigInt(frac)).toString();\n}\n\n/** Now, in epoch milliseconds with sub-millisecond precision. */\nexport function nowMs(): number {\n  return performance.timeOrigin + performance.now();\n}\n\n/** OTel severity numbers (logs data model). */\nexport const SEVERITY = {\n  DEBUG: 5,\n  INFO: 9,\n  WARN: 13,\n  ERROR: 17,\n} as const;\nexport type SeverityText = keyof typeof SEVERITY;\n\n/** One log record, as OTLP/JSON. */\nexport interface LogRecord {\n  timeUnixNano: string;\n  observedTimeUnixNano: string;\n  severityNumber: number;\n  severityText: SeverityText;\n  body: { stringValue: string };\n  attributes: KeyValue[];\n  traceId?: string;\n  spanId?: string;\n  flags?: number;\n}\n\n/** One finished span, as OTLP/JSON. */\nexport interface SpanRecord {\n  traceId: string;\n  spanId: string;\n  parentSpanId?: string;\n  name: string;\n  kind: number;\n  startTimeUnixNano: string;\n  endTimeUnixNano: string;\n  attributes: KeyValue[];\n  droppedAttributesCount?: number;\n  events: Array<{ timeUnixNano: string; name: string; attributes: KeyValue[] }>;\n  links: Array<{ traceId: string; spanId: string; attributes: KeyValue[] }>;\n  status: { code: number; message?: string };\n  /** Grouping key for scopeSpans; not on the wire. */\n  scope: Scope;\n}\n\nexport interface Scope {\n  name: string;\n  version?: string;\n}\n\n/** The ExportLogsServiceRequest body for one batch. */\nexport function logsPayload(\n  resource: KeyValue[],\n  scope: Scope,\n  records: LogRecord[],\n) {\n  return {\n    resourceLogs: [\n      {\n        resource: { attributes: resource },\n        scopeLogs: [{ scope, logRecords: records }],\n      },\n    ],\n  };\n}\n\n/** The ExportTraceServiceRequest body for one batch, spans grouped by scope. */\nexport function tracesPayload(resource: KeyValue[], spans: SpanRecord[]) {\n  const byScope = new Map<\n    string,\n    { scope: Scope; spans: Omit<SpanRecord, \"scope\">[] }\n  >();\n  for (const { scope, ...span } of spans) {\n    const key = `${scope.name}\\u001f${scope.version ?? \"\"}`;\n    let group = byScope.get(key);\n    if (!group) {\n      group = { scope, spans: [] };\n      byScope.set(key, group);\n    }\n    group.spans.push(span);\n  }\n  return {\n    resourceSpans: [\n      {\n        resource: { attributes: resource },\n        scopeSpans: [...byScope.values()],\n      },\n    ],\n  };\n}\n\n// ── Exporter ─────────────────────────────────────────────────────────────\n\nexport type FetchLike = (\n  url: string,\n  init: {\n    method: string;\n    headers: Record<string, string>;\n    body: string;\n    signal?: AbortSignal;\n  },\n) => Promise<{ status: number; headers: { get(name: string): string | null } }>;\n\nexport interface ExporterOptions {\n  /** The OTLP base: `${endpoint}/v1/logs`, `${endpoint}/v1/traces`. */\n  endpoint: string;\n  /** Sent on every request. The keyed ingest requires an allowlisted `Origin`. */\n  headers: Record<string, string>;\n  fetch: FetchLike;\n  /** One request's budget. */\n  timeoutMs: number;\n  /** Retries after the first attempt, on a network error, 429 or 5xx gateway answer. */\n  retries: number;\n  /** Told about a batch that was dropped; never about one that landed. */\n  onError?: (error: Error) => void;\n  /** Test seam for the backoff wait. */\n  sleep?: (ms: number) => Promise<void>;\n}\n\n/** Longest backoff between attempts, whatever Retry-After asks for. */\nexport const MAX_RETRY_DELAY_MS = 5_000;\n\nconst RETRYABLE = new Set([429, 502, 503, 504]);\n\nfunction defaultSleep(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    const t = setTimeout(resolve, ms);\n    (t as { unref?: () => void }).unref?.();\n  });\n}\n\nfunction retryDelay(attempt: number, retryAfter: string | null): number {\n  const seconds = retryAfter === null ? NaN : Number(retryAfter);\n  const base =\n    Number.isFinite(seconds) && seconds >= 0\n      ? seconds * 1000\n      : 250 * 2 ** attempt;\n  return Math.min(MAX_RETRY_DELAY_MS, base);\n}\n\n/**\n * Posts one OTLP/JSON body to `${endpoint}/v1/<signal>`. Resolves true when\n * the collector accepted it, false when it was dropped (after the retries);\n * never rejects.\n */\nexport async function exportSignal(\n  opts: ExporterOptions,\n  signal: \"logs\" | \"traces\",\n  body: unknown,\n): Promise<boolean> {\n  const url = `${opts.endpoint}/v1/${signal}`;\n  const payload = JSON.stringify(body);\n  const sleep = opts.sleep ?? defaultSleep;\n  let last: Error | null = null;\n  for (let attempt = 0; attempt <= opts.retries; attempt++) {\n    let retryAfter: string | null = null;\n    try {\n      const res = await opts.fetch(url, {\n        method: \"POST\",\n        headers: { ...opts.headers, \"content-type\": \"application/json\" },\n        body: payload,\n        signal: AbortSignal.timeout(opts.timeoutMs),\n      });\n      if (res.status >= 200 && res.status < 300) {\n        return true;\n      }\n      last = new Error(`OTLP ${signal} export: HTTP ${res.status}`);\n      if (!RETRYABLE.has(res.status)) {\n        break;\n      }\n      retryAfter = res.headers.get(\"retry-after\");\n    } catch (err) {\n      last = err instanceof Error ? err : new Error(String(err));\n    }\n    if (attempt < opts.retries) {\n      await sleep(retryDelay(attempt, retryAfter));\n    }\n  }\n  try {\n    opts.onError?.(last ?? new Error(`OTLP ${signal} export failed`));\n  } catch {\n    // A diagnostics hook must not break telemetry.\n  }\n  return false;\n}\n\n// ── Batching ─────────────────────────────────────────────────────────────\n\nexport interface BatchOptions<T> {\n  /** Most items held; a push beyond it is dropped and counted. */\n  maxQueue: number;\n  /** Most items in one export. */\n  maxBatch: number;\n  /** How long an item may wait for a batch to fill. */\n  delayMs: number;\n  send(items: T[]): Promise<unknown>;\n}\n\n/**\n * A bounded queue that exports in batches: when a batch fills, when the delay\n * after the first queued item elapses, or on flush(). Its timer is unref'd, so\n * a pending batch never keeps a process alive by itself.\n */\nexport class BatchQueue<T> {\n  private items: T[] = [];\n  private timer: ReturnType<typeof setTimeout> | null = null;\n  private inflight = new Set<Promise<unknown>>();\n  /** Items refused because the queue was full. */\n  dropped = 0;\n\n  constructor(private readonly opts: BatchOptions<T>) {}\n\n  get size(): number {\n    return this.items.length;\n  }\n\n  push(item: T): void {\n    if (this.items.length >= this.opts.maxQueue) {\n      this.dropped++;\n      return;\n    }\n    this.items.push(item);\n    if (this.items.length >= this.opts.maxBatch) {\n      this.drain();\n    } else if (!this.timer) {\n      this.timer = setTimeout(() => {\n        this.timer = null;\n        this.drain();\n      }, this.opts.delayMs);\n      (this.timer as { unref?: () => void }).unref?.();\n    }\n  }\n\n  /** Start exporting everything queued now, without waiting for it. */\n  drain(): void {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = null;\n    }\n    while (this.items.length > 0) {\n      const batch = this.items.splice(0, this.opts.maxBatch);\n      const p = this.opts.send(batch).catch(() => undefined);\n      this.inflight.add(p);\n      void p.finally(() => this.inflight.delete(p));\n    }\n  }\n\n  /** Export everything queued and wait for every export in flight. */\n  async flush(): Promise<void> {\n    this.drain();\n    while (this.inflight.size > 0) {\n      await Promise.all([...this.inflight]);\n    }\n  }\n}\n"]}

package/dist/node-trace.d.ts

@@ -0,0 +1,41 @@
+import { type Context, type ContextManager, type TextMapGetter, type TextMapPropagator, type TextMapSetter, type TimeInput, type Tracer, type TracerProvider } from "@opentelemetry/api";
+import { type Attributes, type SpanRecord } from "./node-otlp.js";
+/** Most events kept on one span. */
+export declare const MAX_SPAN_EVENTS = 128;
+/** Most links kept on one span. */
+export declare const MAX_SPAN_LINKS = 128;
+/** Epoch milliseconds for an OTel TimeInput, as the SDK reads one. */
+export declare function timeInputMs(t: TimeInput | undefined): number;
+type Sink = (span: SpanRecord) => void;
+/** The values every span carries, set once by the entry (app.client, userId). */
+export type GlobalAttributes = () => Attributes;
+/** The context operations a tracer runs on: the global API's, or a manager's own. */
+export interface ContextOps {
+    active(): Context;
+    with<T>(ctx: Context, fn: () => T): T;
+}
+/** A TracerProvider whose spans go to `sink`. */
+export declare class NodeTracerProvider implements TracerProvider {
+    private readonly sink;
+    private readonly globals;
+    private readonly ctx;
+    private readonly tracers;
+    constructor(sink: Sink, globals: GlobalAttributes, ctx: ContextOps);
+    getTracer(name: string, version?: string): Tracer;
+}
+/** The OTel ContextManager over AsyncLocalStorage: context follows async calls. */
+export declare class AsyncLocalContextManager implements ContextManager {
+    private store;
+    active(): Context;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: Context, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    bind<T>(context: Context, target: T): T;
+    enable(): this;
+    disable(): this;
+}
+/** W3C Trace Context: `traceparent` in and out. */
+export declare class TraceparentPropagator implements TextMapPropagator {
+    inject(context: Context, carrier: unknown, setter: TextMapSetter): void;
+    extract(context: Context, carrier: unknown, getter: TextMapGetter): Context;
+    fields(): string[];
+}
+export {};

package/dist/node-trace.js

@@ -0,0 +1,331 @@
+// Part of @reliantlabs/forge-web-runtime — the web twin of forge/pkg.
+//
+// Spans for the `/node` entry: a TracerProvider behind @opentelemetry/api, an
+// AsyncLocalStorage context manager, and the W3C traceparent propagator. Every
+// span is recorded and sampled (a desktop app's main process opens few), and a
+// finished span is handed to the exporter's queue.
+//
+// This is the part of the OpenTelemetry SDK `/node` needs and no more; see
+// node-otlp.ts for why the SDK itself is not a dependency.
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, trace, TraceFlags, } from "@opentelemetry/api";
+import { encodeAttributes, MAX_ATTRIBUTES, nowMs, unixNanos, } from "./node-otlp.js";
+import { TRACEPARENT_RE } from "./trace.js";
+/** Most events kept on one span. */
+export const MAX_SPAN_EVENTS = 128;
+/** Most links kept on one span. */
+export const MAX_SPAN_LINKS = 128;
+const ZERO_TRACE = "0".repeat(32);
+const ZERO_SPAN = "0".repeat(16);
+function hexId(bytes, zero) {
+    let id = randomBytes(bytes).toString("hex");
+    while (id === zero) {
+        id = randomBytes(bytes).toString("hex");
+    }
+    return id;
+}
+/** Epoch milliseconds for an OTel TimeInput, as the SDK reads one. */
+export function timeInputMs(t) {
+    if (t === undefined) {
+        return nowMs();
+    }
+    if (t instanceof Date) {
+        return t.getTime();
+    }
+    if (Array.isArray(t)) {
+        const [s, ns] = t;
+        return s * 1000 + ns / 1e6;
+    }
+    // The SDK's rule: a number below the process's time origin is a
+    // performance.now() reading, anything else is epoch milliseconds.
+    return t < performance.timeOrigin ? performance.timeOrigin + t : t;
+}
+function isTimeInput(v) {
+    return (typeof v === "number" ||
+        v instanceof Date ||
+        (Array.isArray(v) && v.length === 2 && typeof v[0] === "number"));
+}
+class RecordingSpan {
+    ctx;
+    parentSpanId;
+    name;
+    kind;
+    startMs;
+    scope;
+    sink;
+    ended = false;
+    attributes = {};
+    droppedAttributes = 0;
+    events = [];
+    links = [];
+    status = { code: SpanStatusCode.UNSET };
+    constructor(ctx, parentSpanId, name, kind, startMs, scope, sink) {
+        this.ctx = ctx;
+        this.parentSpanId = parentSpanId;
+        this.name = name;
+        this.kind = kind;
+        this.startMs = startMs;
+        this.scope = scope;
+        this.sink = sink;
+    }
+    spanContext() {
+        return this.ctx;
+    }
+    setAttribute(key, value) {
+        if (this.ended || value === undefined || value === null) {
+            return this;
+        }
+        if (!(key in this.attributes) &&
+            Object.keys(this.attributes).length >= MAX_ATTRIBUTES) {
+            this.droppedAttributes++;
+            return this;
+        }
+        this.attributes[key] = value;
+        return this;
+    }
+    setAttributes(attributes) {
+        for (const [k, v] of Object.entries(attributes)) {
+            if (v !== undefined) {
+                this.setAttribute(k, v);
+            }
+        }
+        return this;
+    }
+    addEvent(name, attributesOrStartTime, startTime) {
+        if (this.ended || this.events.length >= MAX_SPAN_EVENTS) {
+            return this;
+        }
+        let attrs;
+        let time = startTime;
+        if (isTimeInput(attributesOrStartTime)) {
+            time = attributesOrStartTime;
+        }
+        else {
+            attrs = attributesOrStartTime;
+        }
+        this.events.push({
+            timeUnixNano: unixNanos(timeInputMs(time)),
+            name,
+            attributes: encodeAttributes(attrs),
+        });
+        return this;
+    }
+    addLink(link) {
+        if (!this.ended && this.links.length < MAX_SPAN_LINKS) {
+            this.links.push({
+                traceId: link.context.traceId,
+                spanId: link.context.spanId,
+                attributes: encodeAttributes(link.attributes),
+            });
+        }
+        return this;
+    }
+    addLinks(links) {
+        for (const l of links) {
+            this.addLink(l);
+        }
+        return this;
+    }
+    setStatus(status) {
+        if (this.ended) {
+            return this;
+        }
+        // OK is final, as in the SDK: a later ERROR does not overwrite it.
+        if (this.status.code === SpanStatusCode.OK) {
+            return this;
+        }
+        this.status = status;
+        return this;
+    }
+    updateName(name) {
+        if (!this.ended) {
+            this.name = name;
+        }
+        return this;
+    }
+    recordException(exception, time) {
+        const attrs = {};
+        if (typeof exception === "string") {
+            attrs["exception.message"] = exception;
+        }
+        else if (exception) {
+            const e = exception;
+            if (typeof e.name === "string")
+                attrs["exception.type"] = e.name;
+            else if (typeof e.code === "string" || typeof e.code === "number")
+                attrs["exception.type"] = String(e.code);
+            if (typeof e.message === "string")
+                attrs["exception.message"] = e.message;
+            if (typeof e.stack === "string")
+                attrs["exception.stacktrace"] = e.stack;
+        }
+        this.addEvent("exception", attrs, time);
+    }
+    end(endTime) {
+        if (this.ended) {
+            return;
+        }
+        this.ended = true;
+        const endMs = Math.max(this.startMs, timeInputMs(endTime));
+        this.sink({
+            traceId: this.ctx.traceId,
+            spanId: this.ctx.spanId,
+            parentSpanId: this.parentSpanId,
+            name: this.name,
+            // OTLP's SpanKind is the API's plus one (0 is UNSPECIFIED on the wire).
+            kind: this.kind + 1,
+            startTimeUnixNano: unixNanos(this.startMs),
+            endTimeUnixNano: unixNanos(endMs),
+            attributes: encodeAttributes(this.attributes),
+            droppedAttributesCount: this.droppedAttributes || undefined,
+            events: this.events,
+            links: this.links,
+            status: this.status.message !== undefined
+                ? { code: this.status.code, message: this.status.message }
+                : { code: this.status.code },
+            scope: this.scope,
+        });
+    }
+    isRecording() {
+        return !this.ended;
+    }
+}
+class NodeTracer {
+    scope;
+    sink;
+    globals;
+    ctx;
+    constructor(scope, sink, globals, ctx) {
+        this.scope = scope;
+        this.sink = sink;
+        this.globals = globals;
+        this.ctx = ctx;
+    }
+    startSpan(name, options = {}, ctx) {
+        const parentCtx = options.root
+            ? undefined
+            : trace.getSpanContext(ctx ?? this.ctx.active());
+        const parent = parentCtx && trace.isSpanContextValid(parentCtx) ? parentCtx : undefined;
+        const spanContext = {
+            traceId: parent?.traceId ?? hexId(16, ZERO_TRACE),
+            spanId: hexId(8, ZERO_SPAN),
+            traceFlags: TraceFlags.SAMPLED,
+        };
+        const span = new RecordingSpan(spanContext, parent?.spanId, name, options.kind ?? SpanKind.INTERNAL, timeInputMs(options.startTime), this.scope, this.sink);
+        for (const [k, v] of Object.entries(this.globals())) {
+            if (v !== undefined)
+                span.setAttribute(k, v);
+        }
+        if (options.attributes) {
+            span.setAttributes(options.attributes);
+        }
+        if (options.links) {
+            span.addLinks(options.links);
+        }
+        return span;
+    }
+    startActiveSpan(name, a, b, c) {
+        let options = {};
+        let parent;
+        let fn;
+        if (typeof a === "function") {
+            fn = a;
+        }
+        else if (typeof b === "function") {
+            options = a ?? {};
+            fn = b;
+        }
+        else {
+            options = a ?? {};
+            parent = b;
+            fn = c;
+        }
+        const base = parent ?? this.ctx.active();
+        const span = this.startSpan(name, options, base);
+        const ctx = trace.setSpan(base, span);
+        return this.ctx.with(ctx, () => fn(span));
+    }
+}
+/** A TracerProvider whose spans go to `sink`. */
+export class NodeTracerProvider {
+    sink;
+    globals;
+    ctx;
+    tracers = new Map();
+    constructor(sink, globals, ctx) {
+        this.sink = sink;
+        this.globals = globals;
+        this.ctx = ctx;
+    }
+    getTracer(name, version) {
+        const key = `${name}\u001f${version ?? ""}`;
+        let t = this.tracers.get(key);
+        if (!t) {
+            t = new NodeTracer(version ? { name, version } : { name }, this.sink, this.globals, this.ctx);
+            this.tracers.set(key, t);
+        }
+        return t;
+    }
+}
+/** The OTel ContextManager over AsyncLocalStorage: context follows async calls. */
+export class AsyncLocalContextManager {
+    store = new AsyncLocalStorage();
+    active() {
+        return this.store.getStore() ?? ROOT_CONTEXT;
+    }
+    with(context, fn, thisArg, ...args) {
+        const cb = thisArg == null ? fn : fn.bind(thisArg);
+        return this.store.run(context, cb, ...args);
+    }
+    bind(context, target) {
+        if (typeof target !== "function") {
+            return target;
+        }
+        const self = this;
+        const fn = target;
+        return function (...args) {
+            return self.with(context, () => fn.apply(this, args));
+        };
+    }
+    enable() {
+        return this;
+    }
+    disable() {
+        this.store.disable();
+        this.store = new AsyncLocalStorage();
+        return this;
+    }
+}
+/** W3C Trace Context: `traceparent` in and out. */
+export class TraceparentPropagator {
+    inject(context, carrier, setter) {
+        const sc = trace.getSpanContext(context);
+        if (!sc || !trace.isSpanContextValid(sc)) {
+            return;
+        }
+        const flags = (sc.traceFlags & TraceFlags.SAMPLED) === TraceFlags.SAMPLED ? "01" : "00";
+        setter.set(carrier, "traceparent", `00-${sc.traceId}-${sc.spanId}-${flags}`);
+    }
+    extract(context, carrier, getter) {
+        const raw = getter.get(carrier, "traceparent");
+        const value = (Array.isArray(raw) ? raw[0] : raw)?.trim();
+        if (!value || !TRACEPARENT_RE.test(value)) {
+            return context;
+        }
+        const [, traceId, spanId, flags] = value.split("-");
+        if (!traceId || !spanId || traceId === ZERO_TRACE || spanId === ZERO_SPAN) {
+            return context;
+        }
+        return trace.setSpanContext(context, {
+            traceId,
+            spanId,
+            traceFlags: parseInt(flags ?? "00", 16) & TraceFlags.SAMPLED,
+            isRemote: true,
+        });
+    }
+    fields() {
+        return ["traceparent"];
+    }
+}
+//# sourceMappingURL=node-trace.js.map