@lostgradient/weft 0.2.0

package/dist/observability/metrics-snapshot.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Public metric snapshot types for Weft observability.
+ *
+ * @module metrics-snapshot
+ */
+/**
+ * Metric aggregation kind used by the Weft metrics catalogue.
+ *
+ * @example
+ * ```ts
+ * import type { MetricType } from '@lostgradient/weft/observability';
+ *
+ * const metricType: MetricType = 'histogram';
+ * console.log(metricType);
+ * ```
+ */
+export type MetricType = 'counter' | 'gauge' | 'histogram';
+/**
+ * Static metadata that describes a metric emitted by Weft.
+ *
+ * @example
+ * ```ts
+ * import { METRICS, type MetricDefinition } from '@lostgradient/weft/observability';
+ *
+ * const workflowDuration: MetricDefinition = METRICS.workflowDuration;
+ * console.log(workflowDuration.name, workflowDuration.unit);
+ * ```
+ */
+export interface MetricDefinition {
+    name: string;
+    description: string;
+    unit: string;
+    type: MetricType;
+}
+/**
+ * Snapshot entry for a monotonically increasing counter.
+ *
+ * @example
+ * ```ts
+ * import type { CounterMetric } from '@lostgradient/weft/observability';
+ *
+ * const startedWorkflows: CounterMetric = { type: 'counter', value: 12 };
+ * console.log(startedWorkflows.value);
+ * ```
+ */
+export type CounterMetric = {
+    type: 'counter';
+    value: number;
+};
+/**
+ * Snapshot entry for a histogram with summary percentiles.
+ *
+ * @example
+ * ```ts
+ * import type { HistogramMetric } from '@lostgradient/weft/observability';
+ *
+ * const duration: HistogramMetric = {
+ *   type: 'histogram',
+ *   count: 3,
+ *   sum: 90,
+ *   p50: 30,
+ *   p99: 40,
+ *   min: 20,
+ *   max: 40,
+ * };
+ * console.log(duration.p99);
+ * ```
+ */
+export type HistogramMetric = {
+    type: 'histogram';
+    count: number;
+    sum: number;
+    p50: number;
+    p99: number;
+    min: number;
+    max: number;
+};
+/**
+ * Snapshot entry for an absolute gauge value.
+ *
+ * @example
+ * ```ts
+ * import type { GaugeMetric } from '@lostgradient/weft/observability';
+ *
+ * const activeWorkflows: GaugeMetric = { type: 'gauge', value: 2 };
+ * console.log(activeWorkflows.value);
+ * ```
+ */
+export type GaugeMetric = {
+    type: 'gauge';
+    value: number;
+};
+/**
+ * Point-in-time values collected by a metrics collector.
+ *
+ * @example
+ * ```ts
+ * import { MetricsCollector, type MetricsSnapshot } from '@lostgradient/weft/observability';
+ *
+ * const collector = new MetricsCollector();
+ * collector.increment('weft.workflow.started');
+ * const snapshot: MetricsSnapshot = collector.snapshot();
+ * console.log(snapshot['weft.workflow.started']);
+ * ```
+ */
+export type MetricsSnapshot = Record<string, CounterMetric | HistogramMetric | GaugeMetric>;

package/dist/observability/metrics.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Metric definitions for Weft observability.
+ *
+ * These constants describe the metrics emitted by Weft interceptors. They
+ * follow OpenTelemetry semantic conventions where applicable, and can be
+ * consumed by any metrics backend that accepts name/description/unit tuples.
+ *
+ * @module metrics
+ */
+import type { MetricsSnapshot } from './metrics-snapshot.ts';
+import type { OpenTelemetryMeter } from './no-op-telemetry';
+export { METRICS } from './metrics-catalog.ts';
+export type { CounterMetric, GaugeMetric, HistogramMetric, MetricDefinition, MetricType, MetricsSnapshot, } from './metrics-snapshot.ts';
+/**
+ * Collects counters, histograms, and gauges for Weft observability.
+ *
+ * Single-threaded — each worker constructs its own collector; concurrent
+ * `record()`/`increment()` calls from the same isolate do not require locking.
+ * Call {@link snapshot} to read all collected values and {@link reset} to
+ * clear them.
+ *
+ * @example
+ * ```ts
+ * import { MetricsCollector } from '@lostgradient/weft/observability';
+ *
+ * const collector = new MetricsCollector();
+ * collector.increment('weft.workflow.started');
+ * collector.record('weft.workflow.duration', 42);
+ * console.log(collector.snapshot());
+ * ```
+ */
+export declare class MetricsCollector {
+    #private;
+    constructor();
+    /** Increment a counter by `value` (default 1). */
+    increment(name: string, value?: number): void;
+    /** Record a histogram observation. Values are kept in a circular buffer capped at {@link MAX_HISTOGRAM_SAMPLES}. */
+    record(name: string, value: number): void;
+    /** Set an absolute gauge value. */
+    gauge(name: string, value: number): void;
+    /** Return a point-in-time snapshot of all collected metrics. */
+    snapshot(): MetricsSnapshot;
+    /** Clear all collected metrics. */
+    reset(): void;
+}
+/**
+ * OpenTelemetry instrument set for Weft metrics.
+ *
+ * @example
+ * ```ts
+ * import { createOpenTelemetryMetrics, type OpenTelemetryMetrics } from '@lostgradient/weft/observability';
+ *
+ * const openTelemetryMetrics: OpenTelemetryMetrics = createOpenTelemetryMetrics('my-service');
+ * openTelemetryMetrics.workflowDuration.record(120);
+ * openTelemetryMetrics.activityAttempts.add(1);
+ * ```
+ */
+export type OpenTelemetryMetrics = {
+    workflowDuration: {
+        record(value: number, attributes?: Record<string, string | number | boolean>): void;
+    };
+    activityDuration: {
+        record(value: number, attributes?: Record<string, string | number | boolean>): void;
+    };
+    activityAttempts: {
+        add(value: number, attributes?: Record<string, string | number | boolean>): void;
+    };
+    activeWorkflows: {
+        add(value: number, attributes?: Record<string, string | number | boolean>): void;
+    };
+};
+/**
+ * Create OpenTelemetry instruments for the standard Weft metrics.
+ *
+ * Accepts an `OpenTelemetryMeter` instance, a string meter name, or nothing. When
+ * called without arguments it uses `getOpenTelemetryApi().metrics.getMeter('weft')`,
+ * which returns a no-op meter when `@opentelemetry/api` is not installed.
+ *
+ * @example
+ * ```ts
+ * import { createOpenTelemetryMetrics } from '@lostgradient/weft/observability';
+ *
+ * // Uses the auto-detected OpenTelemetry API or no-op fallback
+ * const instruments = createOpenTelemetryMetrics('my-service');
+ * instruments.workflowDuration.record(250, { workflow_type: 'greet' });
+ * instruments.activityAttempts.add(1, { activity: 'sendEmail' });
+ * ```
+ */
+export declare function createOpenTelemetryMetrics(meterOrName?: OpenTelemetryMeter | string): OpenTelemetryMetrics;
+/**
+ * Pluggable interface for producing Prometheus text-format output at
+ * `/v1/metrics`. Weft ships with a default implementation that serializes a
+ * {@link MetricsCollector} snapshot, but consumers who already use OpenTelemetry can
+ * adapt `@opentelemetry/exporter-prometheus` (or any other source) to this
+ * interface and pass it via `HandlerOptions.prometheusExporter`.
+ *
+ * Keeping this as an interface rather than hard-wiring the OpenTelemetry SDK avoids
+ * pulling `@opentelemetry/sdk-metrics` into the runtime footprint while still
+ * giving projects that *do* want full OpenTelemetry a clean plug point.
+ *
+ * > [!WARNING] `/v1/metrics` is unauthenticated by default
+ * > The Weft server treats `/v1/metrics` as a public path (see
+ * > `DEFAULT_PUBLIC_PATHS` in `src/server/authentication.ts`) so that
+ * > Prometheus scrapers can read it without credentials. The default
+ * > {@link createMetricsCollectorExporter} only emits aggregate counters and
+ * > histograms with no labels, which is safe to expose. **A custom
+ * > `PrometheusExporter` that emits labels — especially labels containing
+ * > user identifiers, request paths with IDs, or any
+ * > other PII — will leak that data to anyone who can reach the endpoint.**
+ * >
+ * > If your exporter emits sensitive labels, override the default by setting
+ * > `auth.publicPaths` on the server options to a list that does *not*
+ * > include `/v1/metrics`, then scrape it with an authenticated client.
+ */
+export interface PrometheusExporter {
+    /**
+     * Produce Prometheus text-format output for the current state of the metrics
+     * source. Must be safe to call repeatedly — each invocation should reflect
+     * the latest values.
+     */
+    serialize(): string | Promise<string>;
+}
+/**
+ * Serialize a {@link MetricsSnapshot} as Prometheus text format using the
+ * definitions registered in {@link METRICS}. Metrics that aren't in the
+ * snapshot still emit their `# HELP` / `# TYPE` lines with zero values so
+ * Prometheus scrapers see a stable schema.
+ *
+ * @example
+ * ```ts
+ * import { MetricsCollector, serializeMetricsSnapshotForPrometheus } from '@lostgradient/weft/observability';
+ *
+ * const collector = new MetricsCollector();
+ * collector.increment('weft.workflow.started');
+ * const body = serializeMetricsSnapshotForPrometheus(collector.snapshot());
+ * console.log(body.includes('weft_workflow_started_total'));
+ * ```
+ */
+export declare function serializeMetricsSnapshotForPrometheus(snapshot: MetricsSnapshot): string;
+/**
+ * Default {@link PrometheusExporter} that sources its values from a
+ * {@link MetricsCollector}. Equivalent to the previous inline serializer in
+ * the server's `/v1/metrics` handler — extracted here so it can be reused and
+ * so a custom implementation can be substituted without touching the server.
+ *
+ * @example
+ * ```ts
+ * import { createMetricsCollectorExporter } from '@lostgradient/weft/observability';
+ *
+ * const exporter = createMetricsCollectorExporter(undefined);
+ * // Pass to serve() to expose /v1/metrics
+ * // serve({ engine, prometheusExporter: exporter });
+ * console.log(typeof exporter.serialize); // 'function'
+ * ```
+ */
+export declare function createMetricsCollectorExporter(collector: MetricsCollector | undefined): PrometheusExporter;

package/dist/observability/metrics.js

@@ -0,0 +1,152 @@
+import { METRICS } from "./metrics-catalog.js";
+import { getOpenTelemetryApi } from "./no-op-telemetry.js";
+export { METRICS } from "./metrics-catalog.js";
+const MAX_HISTOGRAM_SAMPLES = 1e4;
+
+class CircularBuffer {
+  #buffer;
+  #head = 0;
+  #size = 0;
+  constructor(capacity) {
+    this.#buffer = new Float64Array(capacity);
+  }
+  push(value) {
+    this.#buffer[this.#head] = value;
+    this.#head = (this.#head + 1) % this.#buffer.length;
+    if (this.#size < this.#buffer.length)
+      this.#size++;
+  }
+  toArray() {
+    if (this.#size < this.#buffer.length)
+      return Array.from(this.#buffer.subarray(0, this.#size));
+    const result = Array.from({ length: this.#size });
+    for (let i = 0;i < this.#size; i++)
+      result[i] = this.#buffer[(this.#head + i) % this.#buffer.length];
+    return result;
+  }
+}
+
+export class MetricsCollector {
+  #counters;
+  #histograms;
+  #gauges;
+  constructor() {
+    this.#counters = new Map;
+    this.#histograms = new Map;
+    this.#gauges = new Map;
+  }
+  increment(name, value = 1) {
+    this.#counters.set(name, (this.#counters.get(name) ?? 0) + value);
+  }
+  record(name, value) {
+    let buffer = this.#histograms.get(name);
+    if (!buffer) {
+      buffer = new CircularBuffer(MAX_HISTOGRAM_SAMPLES);
+      this.#histograms.set(name, buffer);
+    }
+    buffer.push(value);
+  }
+  gauge(name, value) {
+    this.#gauges.set(name, value);
+  }
+  snapshot() {
+    const result = {};
+    for (const [name, count] of this.#counters)
+      result[name] = { type: "counter", value: count };
+    for (const [name, buffer] of this.#histograms) {
+      const values = buffer.toArray(), sorted = sortNumbersAscending(values);
+      result[name] = {
+        type: "histogram",
+        count: values.length,
+        sum: sumNumbers(values),
+        p50: sorted[Math.floor(sorted.length * 0.5)] ?? 0,
+        p99: sorted[Math.floor(sorted.length * 0.99)] ?? 0,
+        min: sorted[0] ?? 0,
+        max: sorted[sorted.length - 1] ?? 0
+      };
+    }
+    for (const [name, value] of this.#gauges)
+      result[name] = { type: "gauge", value };
+    return result;
+  }
+  reset() {
+    this.#counters.clear();
+    this.#histograms.clear();
+    this.#gauges.clear();
+  }
+}
+export function createOpenTelemetryMetrics(meterOrName) {
+  let meter;
+  if (typeof meterOrName === "string")
+    meter = getOpenTelemetryApi().metrics.getMeter(meterOrName);
+  else if (meterOrName)
+    meter = meterOrName;
+  else
+    meter = getOpenTelemetryApi().metrics.getMeter("weft");
+  return {
+    workflowDuration: meter.createHistogram("weft.workflow.duration", { unit: "ms" }),
+    activityDuration: meter.createHistogram("weft.activity.duration", { unit: "ms" }),
+    activityAttempts: meter.createCounter("weft.activity.attempts"),
+    activeWorkflows: meter.createUpDownCounter("weft.workflow.active")
+  };
+}
+function sortNumbersAscending(values) {
+  const sorted = [...values];
+  sorted.sort((left, right) => left - right);
+  return sorted;
+}
+function sumNumbers(values) {
+  let total = 0;
+  for (const value of values)
+    total += value;
+  return total;
+}
+function formatHistogramLines(safeName, collected) {
+  const count = collected?.type === "histogram" ? collected.count : 0, sum = collected?.type === "histogram" ? collected.sum : 0;
+  return [`# TYPE ${safeName} histogram`, `${safeName}_count ${count}`, `${safeName}_sum ${sum}`];
+}
+function formatCounterLines(safeName, collected) {
+  const value = collected?.type === "counter" ? collected.value : 0;
+  return [`# TYPE ${safeName} counter`, `${safeName}_total ${value}`];
+}
+function formatGaugeLines(safeName, collected) {
+  const value = collected?.type === "gauge" ? collected.value : 0;
+  return [`# TYPE ${safeName} gauge`, `${safeName} ${value}`];
+}
+const METRIC_FORMATTERS = {
+  histogram: formatHistogramLines,
+  counter: formatCounterLines,
+  gauge: formatGaugeLines
+};
+function formatMetric(metric, snapshot) {
+  const safeName = metric.name.replace(/\./g, "_"), collected = snapshot[metric.name];
+  return [
+    `# HELP ${safeName} ${metric.description}`,
+    ...METRIC_FORMATTERS[metric.type](safeName, collected)
+  ];
+}
+function formatDpmoGaugeLines(snapshot) {
+  const defectsEntry = snapshot[METRICS.dpmoDefects.name], operationsEntry = snapshot[METRICS.dpmoOperations.name], defects = defectsEntry?.type === "counter" ? defectsEntry.value : 0, operations = operationsEntry?.type === "counter" ? operationsEntry.value : 0, value = operations === 0 ? 0 : defects * 1e6 / operations, name = "weft_dpmo";
+  return [
+    `# HELP ${name} Defects per million operations (failed workflows / started workflows * 1e6)`,
+    `# TYPE ${name} gauge`,
+    `${name} ${value}`
+  ];
+}
+export function serializeMetricsSnapshotForPrometheus(snapshot) {
+  const lines = [];
+  for (const metric of Object.values(METRICS))
+    lines.push(...formatMetric(metric, snapshot));
+  lines.push(...formatDpmoGaugeLines(snapshot));
+  return lines.join(`
+`) + `
+`;
+}
+export function createMetricsCollectorExporter(collector) {
+  return {
+    serialize() {
+      const snapshot = collector?.snapshot() ?? {};
+      return serializeMetricsSnapshotForPrometheus(snapshot);
+    }
+  };
+}

package/dist/observability/no-op-telemetry.d.ts

@@ -0,0 +1,168 @@
+/**
+ * OpenTelemetry API loader with no-op fallback.
+ *
+ * Attempts to load `@opentelemetry/api` at runtime. When the package is not
+ * installed, returns lightweight no-op implementations that match the subset
+ * of the OpenTelemetry API that Weft uses. This ensures zero overhead when no SDK is
+ * configured—every method call is a no-op that the JIT can inline away.
+ *
+ * @module no-op-telemetry
+ */
+type SpanAttributes = Record<string, string | number | boolean>;
+export type SpanContext = {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+};
+/** A link to another span, used to express causal relationships without parent-child hierarchy. */
+export type SpanLink = {
+    context: SpanContext;
+    attributes?: SpanAttributes;
+};
+type SpanStatus = {
+    code: number;
+    message?: string;
+};
+/**
+ * Minimal span interface matching the OpenTelemetry API surface we use.
+ *
+ * @example
+ * ```ts
+ * import { getOpenTelemetryApi, type OpenTelemetrySpan } from '@lostgradient/weft/observability';
+ *
+ * const api = getOpenTelemetryApi();
+ * const tracer = api.trace.getTracer('example');
+ * const span: OpenTelemetrySpan = tracer.startSpan('my-operation');
+ * span.setAttribute('user.id', 'u-123');
+ * span.setStatus({ code: api.SpanStatusCode.OK });
+ * span.end();
+ * ```
+ */
+export type OpenTelemetrySpan = {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setStatus(status: SpanStatus): void;
+    recordException(exception: Error | string): void;
+    end(endTime?: number): void;
+    spanContext(): SpanContext;
+};
+type SpanOptions = {
+    attributes?: SpanAttributes;
+    startTime?: number;
+    links?: SpanLink[];
+};
+/**
+ * Minimal tracer interface.
+ *
+ * @example
+ * ```ts
+ * import { getOpenTelemetryApi, type OpenTelemetryTracer } from '@lostgradient/weft/observability';
+ *
+ * const api = getOpenTelemetryApi();
+ * const tracer: OpenTelemetryTracer = api.trace.getTracer('my-service', '1.0.0');
+ * const span = tracer.startSpan('task', { attributes: { 'task.id': '42' } });
+ * span.end();
+ * ```
+ */
+export type OpenTelemetryTracer = {
+    startSpan(name: string, options?: SpanOptions, context?: unknown): OpenTelemetrySpan;
+};
+type InstrumentOptions = {
+    unit?: string;
+    description?: string;
+};
+type OpenTelemetryHistogram = {
+    record(value: number, attributes?: SpanAttributes): void;
+};
+type OpenTelemetryCounter = {
+    add(value: number, attributes?: SpanAttributes): void;
+};
+type OpenTelemetryUpDownCounter = {
+    add(value: number, attributes?: SpanAttributes): void;
+};
+/**
+ * Minimal meter interface.
+ *
+ * @example
+ * ```ts
+ * import { getOpenTelemetryApi, type OpenTelemetryMeter } from '@lostgradient/weft/observability';
+ *
+ * const api = getOpenTelemetryApi();
+ * const meter: OpenTelemetryMeter = api.metrics.getMeter('my-service');
+ * const counter = meter.createCounter('requests.total');
+ * counter.add(1, { route: '/api/start' });
+ * ```
+ */
+export type OpenTelemetryMeter = {
+    createHistogram(name: string, options?: InstrumentOptions): OpenTelemetryHistogram;
+    createCounter(name: string, options?: InstrumentOptions): OpenTelemetryCounter;
+    createUpDownCounter(name: string, options?: InstrumentOptions): OpenTelemetryUpDownCounter;
+};
+/**
+ * The resolved OpenTelemetry API surface Weft consumes.
+ *
+ * @example
+ * ```ts
+ * import { getOpenTelemetryApi, type OpenTelemetryApi } from '@lostgradient/weft/observability';
+ *
+ * const api: OpenTelemetryApi = getOpenTelemetryApi();
+ * const tracer = api.trace.getTracer('my-app');
+ * const span = tracer.startSpan('boot');
+ * span.setStatus({ code: api.SpanStatusCode.OK });
+ * span.end();
+ * ```
+ */
+export type OpenTelemetryApi = {
+    trace: {
+        getTracer(name: string, version?: string): OpenTelemetryTracer;
+        setSpan(context: unknown, span: OpenTelemetrySpan): unknown;
+    };
+    metrics: {
+        getMeter(name: string, version?: string): OpenTelemetryMeter;
+    };
+    context: {
+        ROOT_CONTEXT: unknown;
+        with<T>(ctx: unknown, fn: () => T): T;
+    };
+    SpanStatusCode: {
+        OK: number;
+        ERROR: number;
+        UNSET: number;
+    };
+};
+/** Shared no-op span methods for lightweight span adapters that only need a custom spanContext. */
+export declare const NO_OP_SPAN_METHODS: {
+    readonly setAttribute: (key: string, value: string | number | boolean) => void;
+    readonly setStatus: (status: SpanStatus) => void;
+    readonly recordException: (exception: string | Error) => void;
+    readonly end: (endTime?: number | undefined) => void;
+};
+/** Reset the cached API between tests so specific loader branches can be exercised deterministically. */
+export declare function resetCachedOpenTelemetryApiForTesting(): void;
+/** Check whether a loaded module exposes the subset of the OpenTelemetry API Weft requires. */
+export declare function isSupportedOpenTelemetryApi(value: Partial<OpenTelemetryApi> | undefined): value is OpenTelemetryApi;
+/**
+ * Resolve the installed OpenTelemetry API using an injectable loader.
+ * Returns `undefined` when the module is unavailable or exposes the wrong shape.
+ */
+export declare function resolveInstalledOpenTelemetryApi(loader?: (moduleName: string) => unknown): OpenTelemetryApi | undefined;
+/**
+ * Returns the `@opentelemetry/api` module if installed, otherwise returns
+ * no-op implementations. The result is cached after the first call.
+ *
+ * This function is the single entry point for all OpenTelemetry interactions in Weft.
+ * When no SDK is configured the no-op implementations ensure zero overhead
+ * because every method is an empty function the JIT can inline away.
+ *
+ * @example
+ * ```ts
+ * import { getOpenTelemetryApi } from '@lostgradient/weft/observability';
+ *
+ * // Works whether the OpenTelemetry API package is installed or not
+ * const api = getOpenTelemetryApi();
+ * const tracer = api.trace.getTracer('my-app');
+ * const span = tracer.startSpan('startup');
+ * span.end();
+ * ```
+ */
+export declare function getOpenTelemetryApi(loader?: (moduleName: string) => unknown): OpenTelemetryApi;
+export {};

package/dist/observability/no-op-telemetry.js

@@ -0,0 +1,96 @@
+const NO_OP_SPAN_CONTEXT = {
+  traceId: "0".repeat(32),
+  spanId: "0".repeat(16),
+  traceFlags: 0
+}, NO_OP_SPAN = {
+  setAttribute() {},
+  setStatus() {},
+  recordException() {},
+  end() {},
+  spanContext() {
+    return NO_OP_SPAN_CONTEXT;
+  }
+};
+export const NO_OP_SPAN_METHODS = {
+  setAttribute: (...arguments_) => NO_OP_SPAN.setAttribute(...arguments_),
+  setStatus: (...arguments_) => NO_OP_SPAN.setStatus(...arguments_),
+  recordException: (...arguments_) => NO_OP_SPAN.recordException(...arguments_),
+  end: (...arguments_) => NO_OP_SPAN.end(...arguments_)
+};
+const noOpTracer = {
+  startSpan() {
+    return NO_OP_SPAN;
+  }
+}, noOpInstrument = {
+  record() {},
+  add() {}
+}, noOpMeter = {
+  createHistogram() {
+    return noOpInstrument;
+  },
+  createCounter() {
+    return noOpInstrument;
+  },
+  createUpDownCounter() {
+    return noOpInstrument;
+  }
+}, ROOT_CONTEXT = Symbol("ROOT_CONTEXT"), noOpApi = {
+  trace: {
+    getTracer() {
+      return noOpTracer;
+    },
+    setSpan(context) {
+      return context;
+    }
+  },
+  metrics: {
+    getMeter() {
+      return noOpMeter;
+    }
+  },
+  context: {
+    ROOT_CONTEXT,
+    with(_ctx, fn) {
+      return fn();
+    }
+  },
+  SpanStatusCode: {
+    OK: 1,
+    ERROR: 2,
+    UNSET: 0
+  }
+};
+let cached;
+export function resetCachedOpenTelemetryApiForTesting() {
+  cached = void 0;
+}
+function resolveDefaultOpenTelemetryLoader() {
+  const globalRequire = globalThis.require;
+  if (typeof globalRequire === "function")
+    return (moduleName) => globalRequire(moduleName);
+  return () => {
+    return;
+  };
+}
+export function isSupportedOpenTelemetryApi(value) {
+  return value?.trace?.getTracer != null && value.SpanStatusCode != null;
+}
+export function resolveInstalledOpenTelemetryApi(loader = resolveDefaultOpenTelemetryLoader()) {
+  try {
+    const real = loader("@opentelemetry/api");
+    if (isSupportedOpenTelemetryApi(real))
+      return real;
+  } catch {}
+  return;
+}
+export function getOpenTelemetryApi(loader) {
+  if (cached)
+    return cached;
+  const installed = resolveInstalledOpenTelemetryApi(loader);
+  if (installed) {
+    cached = installed;
+    return cached;
+  }
+  cached = noOpApi;
+  return cached;
+}