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

package/dest/otel.js

@@ -0,0 +1,537 @@
+import { addLogDataHandler } from '@aztec-labs/foundation/log';
+import { DiagConsoleLogger, DiagLogLevel, ROOT_CONTEXT, context, diag, isSpanContextValid, propagation, trace } from '@opentelemetry/api';
+import { W3CTraceContextPropagator } from '@opentelemetry/core';
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { HostMetrics } from '@opentelemetry/host-metrics';
+import { ExplicitBucketHistogramAggregation, InstrumentType, MeterProvider, PeriodicExportingMetricReader, View } from '@opentelemetry/sdk-metrics';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { toMetricOptions } from './metric-utils.js';
+import { MonitoredBatchSpanProcessor } from './monitored_batch_span_processor.js';
+import { NodejsMetricsMonitor } from './nodejs_metrics_monitor.js';
+import { OtelFilterMetricExporter, PublicOtelFilterMetricExporter } from './otel_filter_metric_exporter.js';
+import { registerOtelLoggerProvider } from './otel_logger_provider.js';
+import { getOtelResource } from './otel_resource.js';
+/** Wraps an OpenTelemetry Meter to implement our custom Meter interface */ class WrappedMeter {
+    otelMeter;
+    constructor(otelMeter){
+        this.otelMeter = otelMeter;
+    }
+    createGauge(metric) {
+        return this.otelMeter.createGauge(metric.name, toMetricOptions(metric));
+    }
+    createObservableGauge(metric) {
+        return this.otelMeter.createObservableGauge(metric.name, toMetricOptions(metric));
+    }
+    createHistogram(metric, extraOptions) {
+        return this.otelMeter.createHistogram(metric.name, {
+            ...toMetricOptions(metric),
+            ...extraOptions
+        });
+    }
+    createUpDownCounter(metric) {
+        return this.otelMeter.createUpDownCounter(metric.name, toMetricOptions(metric));
+    }
+    createObservableUpDownCounter(metric) {
+        return this.otelMeter.createObservableUpDownCounter(metric.name, toMetricOptions(metric));
+    }
+    addBatchObservableCallback(callback, observables) {
+        this.otelMeter.addBatchObservableCallback(callback, observables);
+    }
+    removeBatchObservableCallback(callback, observables) {
+        this.otelMeter.removeBatchObservableCallback(callback, observables);
+    }
+}
+export class OpenTelemetryClient {
+    resource;
+    meterProvider;
+    traceProvider;
+    loggerProvider;
+    publicMetricExporter;
+    log;
+    hostMetrics;
+    nodejsMetricsMonitor;
+    meters;
+    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. */ stopPromise;
+    constructor(resource, meterProvider, traceProvider, loggerProvider, publicMetricExporter, log){
+        this.resource = resource;
+        this.meterProvider = meterProvider;
+        this.traceProvider = traceProvider;
+        this.loggerProvider = loggerProvider;
+        this.publicMetricExporter = publicMetricExporter;
+        this.log = log;
+        this.meters = new Map();
+        this.tracers = new Map();
+    }
+    setExportedPublicTelemetry(metrics) {
+        this.publicMetricExporter?.setMetricPrefixes(metrics);
+    }
+    setPublicTelemetryCollectFrom(roles) {
+        this.publicMetricExporter?.setAllowedRoles(roles);
+    }
+    getMeter(name) {
+        let meter = this.meters.get(name);
+        if (!meter) {
+            const otelMeter = this.meterProvider.getMeter(name, this.resource.attributes[ATTR_SERVICE_VERSION]);
+            meter = new WrappedMeter(otelMeter);
+            this.meters.set(name, meter);
+        }
+        return meter;
+    }
+    getTracer(name) {
+        let tracer = this.tracers.get(name);
+        if (!tracer) {
+            tracer = this.traceProvider.getTracer(name, this.resource.attributes[ATTR_SERVICE_VERSION]);
+            this.tracers.set(name, tracer);
+        }
+        return tracer;
+    }
+    start() {
+        this.log.info('Starting OpenTelemetry client');
+        diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+        // Add a callback to the logger to set context data from current trace
+        // Adapted from open-telemetry/opentelemetry-js-contrib PinoInstrumentation._getMixinFunction
+        addLogDataHandler((data)=>{
+            const spanContext = trace.getSpan(context.active())?.spanContext();
+            return spanContext && isSpanContextValid(spanContext) ? {
+                ...data,
+                ['trace_id']: spanContext.traceId,
+                ['span_id']: spanContext.spanId,
+                ['trace_flags']: `0${spanContext.traceFlags.toString(16)}`
+            } : data;
+        });
+        this.hostMetrics = new HostMetrics({
+            name: this.resource.attributes[ATTR_SERVICE_NAME],
+            meterProvider: this.meterProvider
+        });
+        const nodejsMeter = new WrappedMeter(this.meterProvider.getMeter(this.resource.attributes[ATTR_SERVICE_NAME]));
+        this.nodejsMetricsMonitor = new NodejsMetricsMonitor(nodejsMeter);
+        this.hostMetrics.start();
+        this.nodejsMetricsMonitor.start();
+    }
+    isEnabled() {
+        return true;
+    }
+    async flush() {
+        // Flushing after the providers have been shut down throws "invalid attempt to force flush after shutdown".
+        if (this.stopPromise) {
+            return;
+        }
+        await Promise.all([
+            this.meterProvider.forceFlush(),
+            this.loggerProvider?.forceFlush(),
+            this.traceProvider instanceof NodeTracerProvider ? this.traceProvider.forceFlush() : Promise.resolve()
+        ]);
+    }
+    stop() {
+        return this.stopPromise ??= this.doStop();
+    }
+    async doStop() {
+        this.nodejsMetricsMonitor?.stop();
+        const flushAndShutdown = async (provider)=>{
+            if (!provider) {
+                return;
+            }
+            await provider.forceFlush();
+            await provider.shutdown();
+        };
+        await Promise.all([
+            flushAndShutdown(this.meterProvider),
+            flushAndShutdown(this.loggerProvider),
+            this.traceProvider instanceof NodeTracerProvider ? flushAndShutdown(this.traceProvider) : Promise.resolve()
+        ]);
+    }
+    getTraceContext() {
+        const carrier = {};
+        propagation.inject(context.active(), carrier);
+        return carrier['traceparent'];
+    }
+    extractPropagatedContext(traceContext) {
+        const extractedContext = propagation.extract(ROOT_CONTEXT, {
+            traceparent: traceContext
+        });
+        return extractedContext;
+    }
+    static createMeterProvider(resource, exporters) {
+        return new MeterProvider({
+            resource,
+            readers: exporters.map((options)=>new PeriodicExportingMetricReader(options)),
+            views: [
+                // Every histogram matching the selector (type + unit) gets these custom buckets assigned
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'Mmana',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        0.1,
+                        0.5,
+                        1,
+                        2,
+                        4,
+                        8,
+                        10,
+                        25,
+                        50,
+                        100,
+                        500,
+                        1000,
+                        5000,
+                        10000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'tx',
+                    aggregation: new ExplicitBucketHistogramAggregation(// TPS
+                    [
+                        0.1 * 36,
+                        0.2 * 36,
+                        0.5 * 36,
+                        1 * 36,
+                        2 * 36,
+                        5 * 36,
+                        10 * 36,
+                        15 * 36
+                    ].map(Math.ceil), true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 's',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        1,
+                        2,
+                        4,
+                        6,
+                        10,
+                        15,
+                        30,
+                        60,
+                        90,
+                        120,
+                        180,
+                        240,
+                        300,
+                        480,
+                        600,
+                        900,
+                        1200
+                    ], true)
+                }),
+                // Pending-to-mined delay routinely exceeds the 1-minute ceiling of the generic `ms`
+                // view below under load, so it would saturate at 60s. Give this one metric wider
+                // buckets (1s to 10min). This must precede the generic `ms` view: when multiple views
+                // match an instrument, the SDK keeps the first-registered compatible storage, so the
+                // first view in this list wins the bucket boundaries.
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentName: 'aztec.mempool.tx_mined_delay',
+                    instrumentUnit: 'ms',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        1_000,
+                        2_500,
+                        5_000,
+                        7_500,
+                        10_000,
+                        15_000,
+                        30_000,
+                        45_000,
+                        60_000,
+                        90_000,
+                        120_000,
+                        180_000,
+                        300_000,
+                        600_000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'ms',
+                    aggregation: new ExplicitBucketHistogramAggregation(// 10ms to 1 minute
+                    [
+                        10,
+                        20,
+                        35,
+                        50,
+                        75,
+                        100,
+                        250,
+                        500,
+                        750,
+                        1_000,
+                        2_500,
+                        5_000,
+                        7_500,
+                        10_000,
+                        15_000,
+                        30_000,
+                        60_000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'us',
+                    aggregation: new ExplicitBucketHistogramAggregation(// 1us to 1s
+                    [
+                        5,
+                        10,
+                        25,
+                        50,
+                        75,
+                        100,
+                        250,
+                        500,
+                        750,
+                        1_000,
+                        2_500,
+                        5_000,
+                        7_500,
+                        10_000,
+                        25_000,
+                        50_000,
+                        100_000,
+                        250_000,
+                        500_000,
+                        1_000_000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'By',
+                    aggregation: new ExplicitBucketHistogramAggregation(// from 32 bytes to 2MB
+                    [
+                        32,
+                        64,
+                        128,
+                        256,
+                        512,
+                        1024,
+                        2048,
+                        4096,
+                        8192,
+                        16384,
+                        32768,
+                        65536,
+                        131072,
+                        262144,
+                        524288,
+                        1048576,
+                        1572864,
+                        2097152
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'gas/s',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        1_000,
+                        5_000,
+                        10_000,
+                        25_000,
+                        50_000,
+                        100_000,
+                        250_000,
+                        500_000,
+                        750_000,
+                        1_000_000,
+                        2_000_000,
+                        4_000_000,
+                        8_000_000,
+                        10_000_000,
+                        15_000_000,
+                        30_000_000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'mana/s',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        1_000,
+                        5_000,
+                        10_000,
+                        25_000,
+                        50_000,
+                        100_000,
+                        250_000,
+                        500_000,
+                        750_000,
+                        1_000_000,
+                        2_000_000,
+                        4_000_000,
+                        8_000_000,
+                        10_000_000,
+                        15_000_000,
+                        30_000_000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'gas/block',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        1_000,
+                        5_000,
+                        10_000,
+                        25_000,
+                        50_000,
+                        100_000,
+                        250_000,
+                        500_000,
+                        750_000,
+                        1_000_000,
+                        2_000_000,
+                        4_000_000,
+                        8_000_000,
+                        10_000_000,
+                        15_000_000,
+                        30_000_000
+                    ], true)
+                }),
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'gas/tx',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        25_000,
+                        50_000,
+                        100_000,
+                        250_000,
+                        500_000,
+                        750_000,
+                        1_000_000,
+                        2_000_000,
+                        4_000_000,
+                        8_000_000,
+                        10_000_000,
+                        15_000_000,
+                        30_000_000
+                    ], true)
+                }),
+                // L1 gas prices in gwei: priority fees ~0.01-10, base fees ~1-500, spikes to 1000+
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'gwei',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        0.1,
+                        0.5,
+                        1,
+                        2,
+                        5,
+                        10,
+                        20,
+                        50,
+                        100,
+                        200,
+                        500,
+                        1_000
+                    ], true)
+                }),
+                // L1 gas consumption: tx gas 100k-30M, calldata/blob gas varies
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'gas',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        10_000,
+                        50_000,
+                        100_000,
+                        250_000,
+                        500_000,
+                        1_000_000,
+                        2_000_000,
+                        5_000_000,
+                        10_000_000,
+                        15_000_000,
+                        30_000_000
+                    ], true)
+                }),
+                // L1 tx total fee in ETH: typically 0.001 - 1 ETH
+                new View({
+                    instrumentType: InstrumentType.HISTOGRAM,
+                    instrumentUnit: 'eth',
+                    aggregation: new ExplicitBucketHistogramAggregation([
+                        0.0001,
+                        0.0005,
+                        0.001,
+                        0.005,
+                        0.01,
+                        0.05,
+                        0.1,
+                        0.5,
+                        1,
+                        5,
+                        10
+                    ], true)
+                })
+            ]
+        });
+    }
+    static getCustomClientFactory(config) {
+        return (resource, log)=>{
+            const tracerProvider = new NodeTracerProvider({
+                resource,
+                spanProcessors: config.tracesCollectorUrl ? [
+                    new MonitoredBatchSpanProcessor(new OTLPTraceExporter({
+                        url: config.tracesCollectorUrl.href
+                    }), log, {
+                        maxQueueSize: config.otelBspMaxQueueSize,
+                        maxExportBatchSize: config.otelBspMaxExportBatchSize,
+                        scheduledDelayMillis: config.otelBspScheduleDelayMs,
+                        minTraceDurationMs: config.otelMinTraceDurationMs
+                    })
+                ] : []
+            });
+            tracerProvider.register({
+                propagator: new W3CTraceContextPropagator()
+            });
+            const exporters = [];
+            if (config.metricsCollectorUrl) {
+                // Default to a blacklist that is empty (allow all metrics)
+                let filter = [];
+                let mode = 'deny';
+                if (config.otelExcludeMetrics.length > 0) {
+                    // Implement a blacklist as specified in config
+                    log.info(`Excluding metrics from export: ${config.otelExcludeMetrics}`);
+                    filter = config.otelExcludeMetrics;
+                    mode = 'deny';
+                } else if (config.otelIncludeMetrics.length > 0) {
+                    // Implement a whitelist as specified in config
+                    log.info(`Including only specified metrics for export: ${config.otelIncludeMetrics}`);
+                    filter = config.otelIncludeMetrics;
+                    mode = 'allow';
+                }
+                exporters.push({
+                    exporter: new OtelFilterMetricExporter(new OTLPMetricExporter({
+                        url: config.metricsCollectorUrl.href
+                    }), filter, mode),
+                    exportTimeoutMillis: config.otelExportTimeoutMs,
+                    exportIntervalMillis: config.otelCollectIntervalMs
+                });
+            }
+            let publicExporter;
+            if (config.publicMetricsCollectorUrl && !config.publicMetricsOptOut) {
+                log.info(`Exporting public metrics: ${config.publicIncludeMetrics}`, {
+                    publicMetrics: config.publicIncludeMetrics,
+                    collectorUrl: config.publicMetricsCollectorUrl
+                });
+                publicExporter = new PublicOtelFilterMetricExporter(config.publicMetricsCollectFrom, new OTLPMetricExporter({
+                    url: config.publicMetricsCollectorUrl.href
+                }), config.publicIncludeMetrics);
+                exporters.push({
+                    exporter: publicExporter,
+                    exportTimeoutMillis: config.otelExportTimeoutMs,
+                    exportIntervalMillis: config.otelCollectIntervalMs
+                });
+            }
+            const meterProvider = OpenTelemetryClient.createMeterProvider(resource, exporters);
+            const loggerProvider = registerOtelLoggerProvider(resource, config.logsCollectorUrl);
+            return new OpenTelemetryClient(resource, meterProvider, tracerProvider, loggerProvider, publicExporter, log);
+        };
+    }
+    static createAndStart(config, log) {
+        const resource = getOtelResource();
+        const factory = OpenTelemetryClient.getCustomClientFactory(config);
+        const service = factory(resource, log);
+        service.start();
+        return service;
+    }
+}

package/dest/otel_filter_metric_exporter.d.ts

@@ -0,0 +1,20 @@
+import { type ExportResult } from '@opentelemetry/core';
+import type { PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
+export declare class OtelFilterMetricExporter implements PushMetricExporter {
+    private readonly exporter;
+    private metricPrefix;
+    private readonly filter;
+    constructor(exporter: PushMetricExporter, metricPrefix: string[], filter?: 'allow' | 'deny');
+    export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+    private filterMetrics;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    setMetricPrefixes(metrics: string[]): void;
+}
+export declare class PublicOtelFilterMetricExporter extends OtelFilterMetricExporter {
+    private allowedRoles;
+    constructor(allowedRoles: string[], exporter: PushMetricExporter, metricPrefix: string[]);
+    export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void;
+    setAllowedRoles(roles: string[]): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RlbF9maWx0ZXJfbWV0cmljX2V4cG9ydGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvb3RlbF9maWx0ZXJfbWV0cmljX2V4cG9ydGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLFlBQVksRUFBb0IsTUFBTSxxQkFBcUIsQ0FBQztBQUMxRSxPQUFPLEtBQUssRUFBYyxrQkFBa0IsRUFBRSxlQUFlLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUlsRyxxQkFBYSx3QkFBeUIsWUFBVyxrQkFBa0I7SUFFL0QsT0FBTyxDQUFDLFFBQVEsQ0FBQyxRQUFRO0lBQ3pCLE9BQU8sQ0FBQyxZQUFZO0lBQ3BCLE9BQU8sQ0FBQyxRQUFRLENBQUMsTUFBTTtJQUh6QixZQUNtQixRQUFRLEVBQUUsa0JBQWtCLEVBQ3JDLFlBQVksRUFBRSxNQUFNLEVBQUUsRUFDYixNQUFNLEdBQUUsT0FBTyxHQUFHLE1BQWUsRUFRbkQ7SUFFTSxNQUFNLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxjQUFjLEVBQUUsQ0FBQyxNQUFNLEVBQUUsWUFBWSxLQUFLLElBQUksR0FBRyxJQUFJLENBUzVGO0lBRUQsT0FBTyxDQUFDLGFBQWE7SUFjZCxVQUFVLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVqQztJQUVNLFFBQVEsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRS9CO0lBRU0saUJBQWlCLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUV6QztDQUNGO0FBRUQscUJBQWEsOEJBQStCLFNBQVEsd0JBQXdCO0lBRXhFLE9BQU8sQ0FBQyxZQUFZO0lBRHRCLFlBQ1UsWUFBWSxFQUFFLE1BQU0sRUFBRSxFQUM5QixRQUFRLEVBQUUsa0JBQWtCLEVBQzVCLFlBQVksRUFBRSxNQUFNLEVBQUUsRUFHdkI7SUFFZSxNQUFNLENBQUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxjQUFjLEVBQUUsQ0FBQyxNQUFNLEVBQUUsWUFBWSxLQUFLLElBQUksR0FBRyxJQUFJLENBUXJHO0lBRU0sZUFBZSxDQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsUUFFckM7Q0FDRiJ9

package/dest/otel_filter_metric_exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel_filter_metric_exporter.d.ts","sourceRoot":"","sources":["../src/otel_filter_metric_exporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,qBAAqB,CAAC;AAC1E,OAAO,KAAK,EAAc,kBAAkB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAIlG,qBAAa,wBAAyB,YAAW,kBAAkB;IAE/D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAHzB,YACmB,QAAQ,EAAE,kBAAkB,EACrC,YAAY,EAAE,MAAM,EAAE,EACb,MAAM,GAAE,OAAO,GAAG,MAAe,EAQnD;IAEM,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI,CAS5F;IAED,OAAO,CAAC,aAAa;IAcd,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAEjC;IAEM,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/B;IAEM,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAEzC;CACF;AAED,qBAAa,8BAA+B,SAAQ,wBAAwB;IAExE,OAAO,CAAC,YAAY;IADtB,YACU,YAAY,EAAE,MAAM,EAAE,EAC9B,QAAQ,EAAE,kBAAkB,EAC5B,YAAY,EAAE,MAAM,EAAE,EAGvB;IAEe,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI,CAQrG;IAEM,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAErC;CACF"}

package/dest/otel_filter_metric_exporter.js

@@ -0,0 +1,67 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import { AZTEC_NODE_ROLE } from './attributes.js';
+export class OtelFilterMetricExporter {
+    exporter;
+    metricPrefix;
+    filter;
+    constructor(exporter, metricPrefix, filter = 'deny'){
+        this.exporter = exporter;
+        this.metricPrefix = metricPrefix;
+        this.filter = filter;
+        if (exporter.selectAggregation) {
+            this.selectAggregation = exporter.selectAggregation.bind(exporter);
+        }
+        if (exporter.selectAggregationTemporality) {
+            this.selectAggregationTemporality = exporter.selectAggregationTemporality.bind(exporter);
+        }
+    }
+    export(metrics, resultCallback) {
+        const filteredMetrics = {
+            resource: metrics.resource,
+            scopeMetrics: metrics.scopeMetrics.map(({ scope, metrics })=>({
+                    scope,
+                    metrics: this.filterMetrics(metrics)
+                })).filter(({ metrics })=>metrics.length > 0)
+        };
+        this.exporter.export(filteredMetrics, resultCallback);
+    }
+    filterMetrics(metrics) {
+        return metrics.filter((metric)=>{
+            const matched = this.metricPrefix.some((prefix)=>metric.descriptor.name.startsWith(prefix));
+            if (this.filter === 'deny') {
+                return !matched;
+            }
+            if (this.filter === 'allow') {
+                return matched;
+            }
+        });
+    }
+    forceFlush() {
+        return this.exporter.forceFlush();
+    }
+    shutdown() {
+        return this.exporter.shutdown();
+    }
+    setMetricPrefixes(metrics) {
+        this.metricPrefix = metrics;
+    }
+}
+export class PublicOtelFilterMetricExporter extends OtelFilterMetricExporter {
+    allowedRoles;
+    constructor(allowedRoles, exporter, metricPrefix){
+        super(exporter, metricPrefix, 'allow'), this.allowedRoles = allowedRoles;
+    }
+    export(metrics, resultCallback) {
+        const role = String(metrics.resource.attributes[AZTEC_NODE_ROLE] ?? '');
+        if (!role || !this.allowedRoles.includes(role)) {
+            // noop
+            return resultCallback({
+                code: ExportResultCode.SUCCESS
+            });
+        }
+        super.export(metrics, resultCallback);
+    }
+    setAllowedRoles(roles) {
+        this.allowedRoles = roles;
+    }
+}

package/dest/otel_logger_provider.d.ts

@@ -0,0 +1,4 @@
+import type { IResource } from '@opentelemetry/resources';
+import { LoggerProvider } from '@opentelemetry/sdk-logs';
+export declare function registerOtelLoggerProvider(resource: IResource, otelLogsUrl?: URL): LoggerProvider;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RlbF9sb2dnZXJfcHJvdmlkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9vdGVsX2xvZ2dlcl9wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUMxRCxPQUFPLEVBQTJCLGNBQWMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRWxGLHdCQUFnQiwwQkFBMEIsQ0FBQyxRQUFRLEVBQUUsU0FBUyxFQUFFLFdBQVcsQ0FBQyxFQUFFLEdBQUcsa0JBd0JoRiJ9

package/dest/otel_logger_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel_logger_provider.d.ts","sourceRoot":"","sources":["../src/otel_logger_provider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAA2B,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAElF,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,GAAG,kBAwBhF"}

package/dest/otel_logger_provider.js

@@ -0,0 +1,25 @@
+import { logs as otelLogs } from '@opentelemetry/api-logs';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { CompressionAlgorithm } from '@opentelemetry/otlp-exporter-base';
+import { BatchLogRecordProcessor, LoggerProvider } from '@opentelemetry/sdk-logs';
+export function registerOtelLoggerProvider(resource, otelLogsUrl) {
+    const loggerProvider = new LoggerProvider({
+        resource
+    });
+    if (!otelLogsUrl) {
+        // If no URL provided, return it disconnected.
+        return loggerProvider;
+    }
+    const logExporter = new OTLPLogExporter({
+        compression: CompressionAlgorithm.GZIP,
+        url: otelLogsUrl.href
+    });
+    // Add a processor to the logger provider
+    loggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(logExporter, {
+        /** The maximum batch size of every export. It must be smaller or equal to
+       * maxQueueSize. */ maxExportBatchSize: 1024,
+        /** The maximum queue size. After the size is reached log records are dropped. */ maxQueueSize: 4096
+    }));
+    otelLogs.setGlobalLoggerProvider(loggerProvider);
+    return loggerProvider;
+}

package/dest/otel_propagation.d.ts

@@ -0,0 +1,6 @@
+import type { DiagnosticsMiddleware } from '@aztec-labs/foundation/json-rpc/server';
+import type Koa from 'koa';
+import { getJsonRpcServerMetrics } from './json_rpc_server_metrics.js';
+export declare function getOtelJsonRpcPropagationMiddleware(scope?: string): (ctx: Koa.Context, next: () => Promise<void>) => Promise<void>;
+export declare function getOtelJsonRpcDiagnosticsMiddleware(metricsProvider?: typeof getJsonRpcServerMetrics): DiagnosticsMiddleware;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RlbF9wcm9wYWdhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL290ZWxfcHJvcGFnYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUdwRixPQUFPLEtBQUssR0FBRyxNQUFNLEtBQUssQ0FBQztBQUUzQixPQUFPLEVBQUUsdUJBQXVCLEVBQXNCLE1BQU0sOEJBQThCLENBQUM7QUFVM0Ysd0JBQWdCLG1DQUFtQyxDQUNqRCxLQUFLLFNBQWtCLEdBQ3RCLENBQUMsR0FBRyxFQUFFLEdBQUcsQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtRGhFO0FBRUQsd0JBQWdCLG1DQUFtQyxDQUFDLGVBQWUsaUNBQTBCLEdBQUcscUJBQXFCLENBb0NwSCJ9

package/dest/otel_propagation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel_propagation.d.ts","sourceRoot":"","sources":["../src/otel_propagation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAGpF,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAE3B,OAAO,EAAE,uBAAuB,EAAsB,MAAM,8BAA8B,CAAC;AAU3F,wBAAgB,mCAAmC,CACjD,KAAK,SAAkB,GACtB,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAmDhE;AAED,wBAAgB,mCAAmC,CAAC,eAAe,iCAA0B,GAAG,qBAAqB,CAoCpH"}