@aztec-labs/telemetry-client 6.0.0-nightly.20260829

package/dest/monitored_batch_span_processor.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { type Context } from '@opentelemetry/api';
+import type { SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { BatchSpanProcessor, type BufferConfig, type ReadableSpan, type Span } from '@opentelemetry/sdk-trace-node';
+export type MonitoredBatchSpanProcessorConfig = BufferConfig & {
+    minTraceDurationMs?: number;
+};
+/**
+ * Wraps BatchSpanProcessor to emit warnings when spans are dropped due to a full queue.
+ * The standard BatchSpanProcessor silently discards spans when its internal queue reaches
+ * maxQueueSize, making telemetry data loss invisible to operators.
+ */
+export declare class MonitoredBatchSpanProcessor extends BatchSpanProcessor {
+    private readonly maxQueueSize;
+    private readonly maxExportBatchSize;
+    private readonly minTraceDurationMs;
+    private readonly log;
+    private readonly queue;
+    private droppedSinceLastWarning;
+    private totalDropped;
+    private lastWarningTime;
+    private shuttingDown;
+    constructor(exporter: SpanExporter, log: Logger, config?: MonitoredBatchSpanProcessorConfig);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    private shouldDropShortSpan;
+    /** Mirrors the guards the SDK applies before buffering a span. Spans it discards outright never reach the
+     * queue and never reach the exporter, so counting them would leak the estimate upwards forever. */
+    private isQueued;
+    private maybeLogDropWarning;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9uaXRvcmVkX2JhdGNoX3NwYW5fcHJvY2Vzc29yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvbW9uaXRvcmVkX2JhdGNoX3NwYW5fcHJvY2Vzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ3pELE9BQU8sRUFBRSxLQUFLLE9BQU8sRUFBOEIsTUFBTSxvQkFBb0IsQ0FBQztBQUU5RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsS0FBSyxZQUFZLEVBQUUsS0FBSyxZQUFZLEVBQUUsS0FBSyxJQUFJLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQWFwSCxNQUFNLE1BQU0saUNBQWlDLEdBQUcsWUFBWSxHQUFHO0lBQzdELGtCQUFrQixDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQzdCLENBQUM7QUFrQ0Y7Ozs7R0FJRztBQUNILHFCQUFhLDJCQUE0QixTQUFRLGtCQUFrQjtJQUNqRSxPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBUztJQUN0QyxPQUFPLENBQUMsUUFBUSxDQUFDLGtCQUFrQixDQUFTO0lBQzVDLE9BQU8sQ0FBQyxRQUFRLENBQUMsa0JBQWtCLENBQVM7SUFDNUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQVM7SUFDN0IsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQWE7SUFFbkMsT0FBTyxDQUFDLHVCQUF1QixDQUFLO0lBQ3BDLE9BQU8sQ0FBQyxZQUFZLENBQUs7SUFDekIsT0FBTyxDQUFDLGVBQWUsQ0FBSztJQUM1QixPQUFPLENBQUMsWUFBWSxDQUFTO0lBRTdCLFlBQVksUUFBUSxFQUFFLFlBQVksRUFBRSxHQUFHLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUFFLGlDQUFpQyxFQVUxRjtJQUVRLE9BQU8sQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxPQUFPLEdBQUcsSUFBSSxDQUV6RDtJQUVRLEtBQUssQ0FBQyxJQUFJLEVBQUUsWUFBWSxHQUFHLElBQUksQ0FnQnZDO0lBRWMsUUFBUSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FRdkM7SUFFRCxPQUFPLENBQUMsbUJBQW1CO0lBUTNCO3VHQUNtRztJQUNuRyxPQUFPLENBQUMsUUFBUTtJQUloQixPQUFPLENBQUMsbUJBQW1CO0NBa0I1QiJ9

package/dest/monitored_batch_span_processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitored_batch_span_processor.d.ts","sourceRoot":"","sources":["../src/monitored_batch_span_processor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,KAAK,OAAO,EAA8B,MAAM,oBAAoB,CAAC;AAE9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAapH,MAAM,MAAM,iCAAiC,GAAG,YAAY,GAAG;IAC7D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAkCF;;;;GAIG;AACH,qBAAa,2BAA4B,SAAQ,kBAAkB;IACjE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IAEnC,OAAO,CAAC,uBAAuB,CAAK;IACpC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,YAAY,CAAS;IAE7B,YAAY,QAAQ,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iCAAiC,EAU1F;IAEQ,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI,CAEzD;IAEQ,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAgBvC;IAEc,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAQvC;IAED,OAAO,CAAC,mBAAmB;IAQ3B;uGACmG;IACnG,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,mBAAmB;CAkB5B"}

package/dest/monitored_batch_span_processor.js

@@ -0,0 +1,111 @@
+import { SpanStatusCode, TraceFlags } from '@opentelemetry/api';
+import { hrTimeToMilliseconds } from '@opentelemetry/core';
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
+/** Minimum interval between drop warnings to avoid log spam. */ const DROP_WARNING_INTERVAL_MS = 30_000;
+const DEFAULT_MIN_TRACE_DURATION_MS = 10;
+const DEFAULT_MAX_QUEUE_SIZE = 65536;
+/** Cap on the per-export batch size, so a large queue can actually be drained instead of dribbling out
+ * at the SDK default of 512 spans per scheduled export. Kept <= maxQueueSize per the BatchSpanProcessor contract. */ const DEFAULT_MAX_EXPORT_BATCH_SIZE = 4096;
+/**
+ * Delegating exporter that reports how many spans left the queue.
+ *
+ * `BatchSpanProcessor` removes a batch from its internal buffer and hands it straight to
+ * `exporter.export()` — exactly once per batch — so this is an exact drain signal. Spans in flight are
+ * already off the queue, which matches how the SDK evaluates its own `maxQueueSize` limit.
+ */ class DrainCountingExporter {
+    inner;
+    queue;
+    constructor(inner, queue){
+        this.inner = inner;
+        this.queue = queue;
+    }
+    export(spans, resultCallback) {
+        this.queue.size = Math.max(0, this.queue.size - spans.length);
+        this.inner.export(spans, resultCallback);
+    }
+    shutdown() {
+        return this.inner.shutdown();
+    }
+    forceFlush() {
+        return this.inner.forceFlush?.() ?? Promise.resolve();
+    }
+}
+/**
+ * Wraps BatchSpanProcessor to emit warnings when spans are dropped due to a full queue.
+ * The standard BatchSpanProcessor silently discards spans when its internal queue reaches
+ * maxQueueSize, making telemetry data loss invisible to operators.
+ */ export class MonitoredBatchSpanProcessor extends BatchSpanProcessor {
+    maxQueueSize;
+    maxExportBatchSize;
+    minTraceDurationMs;
+    log;
+    queue;
+    droppedSinceLastWarning = 0;
+    totalDropped = 0;
+    lastWarningTime = 0;
+    shuttingDown = false;
+    constructor(exporter, log, config){
+        const maxQueueSize = config?.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+        const maxExportBatchSize = Math.min(config?.maxExportBatchSize ?? DEFAULT_MAX_EXPORT_BATCH_SIZE, maxQueueSize);
+        const queue = {
+            size: 0
+        };
+        super(new DrainCountingExporter(exporter, queue), {
+            ...config,
+            maxQueueSize,
+            maxExportBatchSize
+        });
+        this.queue = queue;
+        this.maxQueueSize = maxQueueSize;
+        this.maxExportBatchSize = maxExportBatchSize;
+        this.minTraceDurationMs = Math.max(0, config?.minTraceDurationMs ?? DEFAULT_MIN_TRACE_DURATION_MS);
+        this.log = log;
+    }
+    onStart(span, parentContext) {
+        super.onStart(span, parentContext);
+    }
+    onEnd(span) {
+        if (this.shouldDropShortSpan(span)) {
+            return;
+        }
+        if (this.isQueued(span)) {
+            if (this.queue.size >= this.maxQueueSize) {
+                this.droppedSinceLastWarning++;
+                this.totalDropped++;
+                this.maybeLogDropWarning();
+            } else {
+                this.queue.size++;
+            }
+        }
+        super.onEnd(span);
+    }
+    async shutdown() {
+        this.shuttingDown = true;
+        if (this.totalDropped > 0) {
+            this.log.warn(`BatchSpanProcessor shutting down with ${this.totalDropped} total spans dropped`, {
+                totalDropped: this.totalDropped
+            });
+        }
+        await super.shutdown();
+    }
+    shouldDropShortSpan(span) {
+        return this.minTraceDurationMs > 0 && span.status.code !== SpanStatusCode.ERROR && hrTimeToMilliseconds(span.duration) < this.minTraceDurationMs;
+    }
+    /** Mirrors the guards the SDK applies before buffering a span. Spans it discards outright never reach the
+   * queue and never reach the exporter, so counting them would leak the estimate upwards forever. */ isQueued(span) {
+        return !this.shuttingDown && (span.spanContext().traceFlags & TraceFlags.SAMPLED) !== 0;
+    }
+    maybeLogDropWarning() {
+        const now = Date.now();
+        if (now - this.lastWarningTime >= DROP_WARNING_INTERVAL_MS) {
+            this.log.warn(`BatchSpanProcessor dropping spans: queue full (maxQueueSize=${this.maxQueueSize}, ` + `maxExportBatchSize=${this.maxExportBatchSize}). ` + `${this.droppedSinceLastWarning} dropped since last warning, ${this.totalDropped} total.`, {
+                droppedSinceLastWarning: this.droppedSinceLastWarning,
+                totalDropped: this.totalDropped,
+                maxQueueSize: this.maxQueueSize,
+                maxExportBatchSize: this.maxExportBatchSize
+            });
+            this.droppedSinceLastWarning = 0;
+            this.lastWarningTime = now;
+        }
+    }
+}

package/dest/nodejs_metrics_monitor.d.ts

@@ -0,0 +1,19 @@
+import type { Meter } from './telemetry.js';
+/** Monitors Node.js runtime metrics */
+export declare class NodejsMetricsMonitor {
+    private meter;
+    private eventLoopDelayGauges;
+    private memoryGauges;
+    private eventLoopUilization;
+    private eventLoopTime;
+    private started;
+    private lastELU;
+    private eventLoopDelay;
+    constructor(meter: Meter);
+    start(): void;
+    stop(): void;
+    private measure;
+    private measureMemoryUsage;
+    private measureEventLoopDelay;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZWpzX21ldHJpY3NfbW9uaXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL25vZGVqc19tZXRyaWNzX21vbml0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUEsT0FBTyxLQUFLLEVBQXlCLEtBQUssRUFBa0MsTUFBTSxnQkFBZ0IsQ0FBQztBQUVuRyx1Q0FBdUM7QUFDdkMscUJBQWEsb0JBQW9CO0lBdUJuQixPQUFPLENBQUMsS0FBSztJQXRCekIsT0FBTyxDQUFDLG9CQUFvQixDQVExQjtJQUlGLE9BQU8sQ0FBQyxZQUFZLENBQW9FO0lBRXhGLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBa0I7SUFDN0MsT0FBTyxDQUFDLGFBQWEsQ0FBZ0I7SUFFckMsT0FBTyxDQUFDLE9BQU8sQ0FBUztJQUV4QixPQUFPLENBQUMsT0FBTyxDQUFtQztJQUNsRCxPQUFPLENBQUMsY0FBYyxDQUFvQjtJQUUxQyxZQUFvQixLQUFLLEVBQUUsS0FBSyxFQXVCL0I7SUFFRCxLQUFLLElBQUksSUFBSSxDQVlaO0lBRUQsSUFBSSxJQUFJLElBQUksQ0FZWDtJQUVELE9BQU8sQ0FBQyxPQUFPLENBR2I7SUFFRixPQUFPLENBQUMsa0JBQWtCLENBT3hCO0lBRUYsT0FBTyxDQUFDLHFCQUFxQixDQXlCM0I7Q0FDSCJ9

package/dest/nodejs_metrics_monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodejs_metrics_monitor.d.ts","sourceRoot":"","sources":["../src/nodejs_metrics_monitor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAyB,KAAK,EAAkC,MAAM,gBAAgB,CAAC;AAEnG,uCAAuC;AACvC,qBAAa,oBAAoB;IAuBnB,OAAO,CAAC,KAAK;IAtBzB,OAAO,CAAC,oBAAoB,CAQ1B;IAIF,OAAO,CAAC,YAAY,CAAoE;IAExF,OAAO,CAAC,mBAAmB,CAAkB;IAC7C,OAAO,CAAC,aAAa,CAAgB;IAErC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,cAAc,CAAoB;IAE1C,YAAoB,KAAK,EAAE,KAAK,EAuB/B;IAED,KAAK,IAAI,IAAI,CAYZ;IAED,IAAI,IAAI,IAAI,CAYX;IAED,OAAO,CAAC,OAAO,CAGb;IAEF,OAAO,CAAC,kBAAkB,CAOxB;IAEF,OAAO,CAAC,qBAAqB,CAyB3B;CACH"}

package/dest/nodejs_metrics_monitor.js

@@ -0,0 +1,115 @@
+import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
+import * as Attributes from './attributes.js';
+import { createUpDownCounterWithDefault } from './metric-utils.js';
+import * as Metrics from './metrics.js';
+/** Monitors Node.js runtime metrics */ export class NodejsMetricsMonitor {
+    meter;
+    eventLoopDelayGauges;
+    // skip `rss` because that's already tracked by @opentelemetry/host-metrics
+    // description of each field here https://nodejs.org/api/process.html#processmemoryusage
+    memoryGauges;
+    eventLoopUilization;
+    eventLoopTime;
+    started;
+    lastELU;
+    eventLoopDelay;
+    constructor(meter){
+        this.meter = meter;
+        this.started = false;
+        this.measure = (obs)=>{
+            this.measureMemoryUsage(obs);
+            this.measureEventLoopDelay(obs);
+        };
+        this.measureMemoryUsage = (observer)=>{
+            const mem = process.memoryUsage();
+            observer.observe(this.memoryGauges.heapUsed, mem.heapUsed);
+            observer.observe(this.memoryGauges.heapTotal, mem.heapTotal);
+            observer.observe(this.memoryGauges.arrayBuffers, mem.arrayBuffers);
+            observer.observe(this.memoryGauges.external, mem.external);
+        };
+        this.measureEventLoopDelay = (obs)=>{
+            const newELU = performance.eventLoopUtilization();
+            const delta = performance.eventLoopUtilization(newELU, this.lastELU);
+            this.lastELU = newELU;
+            // `utilization` [0,1] represents how much the event loop is busy vs waiting for new events to come in
+            // This should be corelated with CPU usage to gauge the performance characteristics of services
+            // 100% utilization leads to high latency because the event loop is _always_ busy, there's no breathing room for events to be processed quickly.
+            // Docs and examples:
+            // - https://nodesource.com/blog/event-loop-utilization-nodejs
+            // - https://youtu.be/WetXnEPraYM
+            obs.observe(this.eventLoopUilization, delta.utilization);
+            this.eventLoopTime.add(Math.trunc(delta.idle), {
+                [Attributes.NODEJS_EVENT_LOOP_STATE]: 'idle'
+            });
+            this.eventLoopTime.add(Math.trunc(delta.active), {
+                [Attributes.NODEJS_EVENT_LOOP_STATE]: 'active'
+            });
+            safeObserveInt(obs, this.eventLoopDelayGauges.min, this.eventLoopDelay.min);
+            safeObserveInt(obs, this.eventLoopDelayGauges.mean, this.eventLoopDelay.mean);
+            safeObserveInt(obs, this.eventLoopDelayGauges.max, this.eventLoopDelay.max);
+            safeObserveInt(obs, this.eventLoopDelayGauges.stddev, this.eventLoopDelay.stddev);
+            safeObserveInt(obs, this.eventLoopDelayGauges.p50, this.eventLoopDelay.percentile(50));
+            safeObserveInt(obs, this.eventLoopDelayGauges.p90, this.eventLoopDelay.percentile(90));
+            safeObserveInt(obs, this.eventLoopDelayGauges.p99, this.eventLoopDelay.percentile(99));
+            this.eventLoopDelay.reset();
+        };
+        this.eventLoopDelayGauges = {
+            min: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MIN),
+            mean: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MEAN),
+            max: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MAX),
+            stddev: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_STDDEV),
+            p50: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P50),
+            p90: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P90),
+            p99: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P99)
+        };
+        this.eventLoopUilization = meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_UTILIZATION);
+        this.eventLoopTime = createUpDownCounterWithDefault(meter, Metrics.NODEJS_EVENT_LOOP_TIME, {
+            [Attributes.NODEJS_EVENT_LOOP_STATE]: [
+                'idle',
+                'active'
+            ]
+        });
+        this.eventLoopDelay = monitorEventLoopDelay();
+        this.memoryGauges = {
+            heapUsed: meter.createObservableGauge(Metrics.NODEJS_MEMORY_HEAP_USAGE),
+            heapTotal: meter.createObservableGauge(Metrics.NODEJS_MEMORY_HEAP_TOTAL),
+            arrayBuffers: meter.createObservableGauge(Metrics.NODEJS_MEMORY_BUFFER_USAGE),
+            external: meter.createObservableGauge(Metrics.NODEJS_MEMORY_NATIVE_USAGE)
+        };
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.lastELU = performance.eventLoopUtilization();
+        this.eventLoopDelay.enable();
+        this.meter.addBatchObservableCallback(this.measure, [
+            this.eventLoopUilization,
+            ...Object.values(this.eventLoopDelayGauges),
+            ...Object.values(this.memoryGauges)
+        ]);
+    }
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        this.meter.removeBatchObservableCallback(this.measure, [
+            this.eventLoopUilization,
+            ...Object.values(this.eventLoopDelayGauges),
+            ...Object.values(this.memoryGauges)
+        ]);
+        this.eventLoopDelay.disable();
+        this.eventLoopDelay.reset();
+        this.lastELU = undefined;
+    }
+    measure;
+    measureMemoryUsage;
+    measureEventLoopDelay;
+}
+function safeObserveInt(observer, metric, value, attrs) {
+    // discard NaN, Infinity, -Infinity
+    if (!Number.isFinite(value)) {
+        return;
+    }
+    observer.observe(metric, Math.trunc(value), attrs);
+}

package/dest/noop.d.ts

@@ -0,0 +1,19 @@
+import { type Context, type Span, type Tracer } from '@opentelemetry/api';
+import type { Meter, TelemetryClient } from './telemetry.js';
+export declare class NoopTelemetryClient implements TelemetryClient {
+    private meter;
+    setExportedPublicTelemetry(_prefixes: string[]): void;
+    setPublicTelemetryCollectFrom(_roles: string[]): void;
+    getMeter(): Meter;
+    getTracer(): Tracer;
+    stop(): Promise<void>;
+    flush(): Promise<void>;
+    isEnabled(): boolean;
+    getTraceContext(): string | undefined;
+    extractPropagatedContext(_traceContext: string): Context | undefined;
+}
+export declare class NoopTracer implements Tracer {
+    startSpan(): Span;
+    startActiveSpan<F extends (...args: any[]) => any>(_name: string, ...args: unknown[]): ReturnType<F>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL25vb3AudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssT0FBTyxFQUFFLEtBQUssSUFBSSxFQUFvQixLQUFLLE1BQU0sRUFBbUIsTUFBTSxvQkFBb0IsQ0FBQztBQUc3RyxPQUFPLEtBQUssRUFHVixLQUFLLEVBR0wsZUFBZSxFQUVoQixNQUFNLGdCQUFnQixDQUFDO0FBeUN4QixxQkFBYSxtQkFBb0IsWUFBVyxlQUFlO0lBQ3pELE9BQU8sQ0FBQyxLQUFLLENBQW1CO0lBRWhDLDBCQUEwQixDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUc7SUFDeEQsNkJBQTZCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBRztJQUV4RCxRQUFRLElBQUksS0FBSyxDQUVoQjtJQUVELFNBQVMsSUFBSSxNQUFNLENBRWxCO0lBRUQsSUFBSSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFcEI7SUFFRCxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVyQjtJQUVELFNBQVMsWUFFUjtJQUVELGVBQWUsSUFBSSxNQUFNLEdBQUcsU0FBUyxDQUVwQztJQUVELHdCQUF3QixDQUFDLGFBQWEsRUFBRSxNQUFNLEdBQUcsT0FBTyxHQUFHLFNBQVMsQ0FFbkU7Q0FDRjtBQUtELHFCQUFhLFVBQVcsWUFBVyxNQUFNO0lBQ3ZDLFNBQVMsSUFBSSxJQUFJLENBRWhCO0lBRUQsZUFBZSxDQUFDLENBQUMsU0FBUyxDQUFDLEdBQUcsSUFBSSxFQUFFLEdBQUcsRUFBRSxLQUFLLEdBQUcsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEdBQUcsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FJbkc7Q0FDRiJ9

package/dest/noop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../src/noop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,IAAI,EAAoB,KAAK,MAAM,EAAmB,MAAM,oBAAoB,CAAC;AAG7G,OAAO,KAAK,EAGV,KAAK,EAGL,eAAe,EAEhB,MAAM,gBAAgB,CAAC;AAyCxB,qBAAa,mBAAoB,YAAW,eAAe;IACzD,OAAO,CAAC,KAAK,CAAmB;IAEhC,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAG;IACxD,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAG;IAExD,QAAQ,IAAI,KAAK,CAEhB;IAED,SAAS,IAAI,MAAM,CAElB;IAED,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAEpB;IAED,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;IAED,SAAS,YAER;IAED,eAAe,IAAI,MAAM,GAAG,SAAS,CAEpC;IAED,wBAAwB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAEnE;CACF;AAKD,qBAAa,UAAW,YAAW,MAAM;IACvC,SAAS,IAAI,IAAI,CAEhB;IAED,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAInG;CACF"}

package/dest/noop.js

@@ -0,0 +1,104 @@
+import { createNoopMeter } from '@opentelemetry/api';
+/** A no-op meter that implements our custom Meter interface */ class NoopMeter {
+    otelMeter = createNoopMeter();
+    createGauge(_metric) {
+        return this.otelMeter.createGauge('');
+    }
+    createObservableGauge(_metric) {
+        return this.otelMeter.createObservableGauge('');
+    }
+    createHistogram(_metric, _extraOptions) {
+        return this.otelMeter.createHistogram('');
+    }
+    createUpDownCounter(_metric) {
+        return this.otelMeter.createUpDownCounter('');
+    }
+    createObservableUpDownCounter(_metric) {
+        return this.otelMeter.createObservableUpDownCounter('');
+    }
+    addBatchObservableCallback(callback, observables) {
+        this.otelMeter.addBatchObservableCallback(callback, observables);
+    }
+    removeBatchObservableCallback(callback, observables) {
+        this.otelMeter.removeBatchObservableCallback(callback, observables);
+    }
+}
+export class NoopTelemetryClient {
+    meter = new NoopMeter();
+    setExportedPublicTelemetry(_prefixes) {}
+    setPublicTelemetryCollectFrom(_roles) {}
+    getMeter() {
+        return this.meter;
+    }
+    getTracer() {
+        return new NoopTracer();
+    }
+    stop() {
+        return Promise.resolve();
+    }
+    flush() {
+        return Promise.resolve();
+    }
+    isEnabled() {
+        return false;
+    }
+    getTraceContext() {
+        return undefined;
+    }
+    extractPropagatedContext(_traceContext) {
+        return undefined;
+    }
+}
+// @opentelemetry/api internally uses NoopTracer and NoopSpan but they're not exported
+// make our own versions
+// https://github.com/open-telemetry/opentelemetry-js/issues/4518#issuecomment-2179405444
+export class NoopTracer {
+    startSpan() {
+        return new NoopSpan();
+    }
+    startActiveSpan(_name, ...args) {
+        // there are three different signatures for startActiveSpan, grab the function, we don't care about the rest
+        const fn = args.find((arg)=>typeof arg === 'function');
+        return fn(new NoopSpan());
+    }
+}
+class NoopSpan {
+    recording = true;
+    addEvent() {
+        return this;
+    }
+    addLink() {
+        return this;
+    }
+    addLinks() {
+        return this;
+    }
+    end() {
+        this.recording = false;
+    }
+    isRecording() {
+        return this.recording;
+    }
+    recordException() {
+        return;
+    }
+    setAttribute() {
+        return this;
+    }
+    setAttributes() {
+        return this;
+    }
+    setStatus() {
+        return this;
+    }
+    spanContext() {
+        return {
+            spanId: '',
+            traceId: '',
+            traceFlags: 0
+        };
+    }
+    updateName() {
+        return this;
+    }
+}

package/dest/otel.d.ts

@@ -0,0 +1,43 @@
+import { type Logger } from '@aztec-labs/foundation/log';
+import { type Context, type Tracer, type TracerProvider } from '@opentelemetry/api';
+import { HostMetrics } from '@opentelemetry/host-metrics';
+import type { IResource } from '@opentelemetry/resources';
+import type { LoggerProvider } from '@opentelemetry/sdk-logs';
+import { MeterProvider, type PeriodicExportingMetricReaderOptions } from '@opentelemetry/sdk-metrics';
+import type { TelemetryClientConfig } from './config.js';
+import { NodejsMetricsMonitor } from './nodejs_metrics_monitor.js';
+import { PublicOtelFilterMetricExporter } from './otel_filter_metric_exporter.js';
+import type { Meter, TelemetryClient } from './telemetry.js';
+export type OpenTelemetryClientFactory = (resource: IResource, log: Logger) => OpenTelemetryClient;
+export declare class OpenTelemetryClient implements TelemetryClient {
+    private resource;
+    private meterProvider;
+    private traceProvider;
+    private loggerProvider;
+    private publicMetricExporter;
+    private log;
+    hostMetrics: HostMetrics | undefined;
+    nodejsMetricsMonitor: NodejsMetricsMonitor | undefined;
+    private meters;
+    private tracers;
+    /** Memoized shutdown promise. The telemetry client is shared between the aztec-node and an embedded prover-node,
+     * so stop() can be invoked more than once; the providers throw "shutdown may only be called once" and
+     * "invalid attempt to force flush after shutdown" if that happens. Guarding here makes stop()/flush() idempotent. */
+    private stopPromise;
+    protected constructor(resource: IResource, meterProvider: MeterProvider, traceProvider: TracerProvider, loggerProvider: LoggerProvider | undefined, publicMetricExporter: PublicOtelFilterMetricExporter | undefined, log: Logger);
+    setExportedPublicTelemetry(metrics: string[]): void;
+    setPublicTelemetryCollectFrom(roles: string[]): void;
+    getMeter(name: string): Meter;
+    getTracer(name: string): Tracer;
+    start(): void;
+    isEnabled(): boolean;
+    flush(): Promise<void>;
+    stop(): Promise<void>;
+    private doStop;
+    getTraceContext(): string | undefined;
+    extractPropagatedContext(traceContext: string): Context;
+    static createMeterProvider(resource: IResource, exporters: Array<PeriodicExportingMetricReaderOptions>): MeterProvider;
+    private static getCustomClientFactory;
+    static createAndStart(config: TelemetryClientConfig, log: Logger): OpenTelemetryClient;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/otel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.d.ts","sourceRoot":"","sources":["../src/otel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,MAAM,EAAqB,MAAM,4BAA4B,CAAC;AAC1F,OAAO,EACL,KAAK,OAAO,EAKZ,KAAK,MAAM,EACX,KAAK,cAAc,EAMpB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAGL,aAAa,EAEb,KAAK,oCAAoC,EAE1C,MAAM,4BAA4B,CAAC;AAIpC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAIzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAA4B,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAG5G,OAAO,KAAK,EAGV,KAAK,EAGL,eAAe,EAEhB,MAAM,gBAAgB,CAAC;AAyCxB,MAAM,MAAM,0BAA0B,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,KAAK,mBAAmB,CAAC;AAEnG,qBAAa,mBAAoB,YAAW,eAAe;IAYvD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,GAAG;IAhBb,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;IACrC,oBAAoB,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACvD,OAAO,CAAC,MAAM,CAA8D;IAC5E,OAAO,CAAC,OAAO,CAAkD;IAEjE;;yHAEqH;IACrH,OAAO,CAAC,WAAW,CAA4B;IAE/C,SAAS,aACC,QAAQ,EAAE,SAAS,EACnB,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,cAAc,EAC7B,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,oBAAoB,EAAE,8BAA8B,GAAG,SAAS,EAChE,GAAG,EAAE,MAAM,EACjB;IAEJ,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAElD;IAED,6BAA6B,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAEnD;IAED,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAQ5B;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9B;IAEM,KAAK,SA8BX;IAEM,SAAS,YAEf;IAEY,KAAK,kBAUjB;IAEM,IAAI,kBAEV;YAEa,MAAM;IAkBb,eAAe,IAAI,MAAM,GAAG,SAAS,CAI3C;IAEM,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAK7D;IAED,OAAc,mBAAmB,CAC/B,QAAQ,EAAE,SAAS,EACnB,SAAS,EAAE,KAAK,CAAC,oCAAoC,CAAC,GACrD,aAAa,CA8Kf;IAED,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAwErC,OAAc,cAAc,CAAC,MAAM,EAAE,qBAAqB,EAAE,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAQ5F;CACF"}