@aztec/telemetry-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/dest/otel.js

@@ -1,38 +1,80 @@
 import { addLogDataHandler } from '@aztec/foundation/log';
-import { DiagConsoleLogger, DiagLogLevel, context, diag, isSpanContextValid, trace } from '@opentelemetry/api';
+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 { BatchSpanProcessor, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-import { EventLoopMonitor } from './event_loop_monitor.js';
-import { OtelFilterMetricExporter } from './otel_filter_metric_exporter.js';
+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;
-    eventLoopMonitor;
+    nodejsMetricsMonitor;
     meters;
     tracers;
-    constructor(resource, meterProvider, traceProvider, loggerProvider, log){
+    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) {
-            meter = this.meterProvider.getMeter(name, this.resource.attributes[ATTR_SERVICE_VERSION]);
+            const otelMeter = this.meterProvider.getMeter(name, this.resource.attributes[ATTR_SERVICE_VERSION]);
+            meter = new WrappedMeter(otelMeter);
             this.meters.set(name, meter);
         }
         return meter;
@@ -63,9 +105,10 @@ export class OpenTelemetryClient {
             name: this.resource.attributes[ATTR_SERVICE_NAME],
             meterProvider: this.meterProvider
         });
-        this.eventLoopMonitor = new EventLoopMonitor(this.meterProvider.getMeter(this.resource.attributes[ATTR_SERVICE_NAME]));
+        const nodejsMeter = new WrappedMeter(this.meterProvider.getMeter(this.resource.attributes[ATTR_SERVICE_NAME]));
+        this.nodejsMetricsMonitor = new NodejsMetricsMonitor(nodejsMeter);
         this.hostMetrics.start();
-        this.eventLoopMonitor.start();
+        this.nodejsMetricsMonitor.start();
     }
     isEnabled() {
         return true;
@@ -78,7 +121,7 @@ export class OpenTelemetryClient {
         ]);
     }
     async stop() {
-        this.eventLoopMonitor?.stop();
+        this.nodejsMetricsMonitor?.stop();
         const flushAndShutdown = async (provider)=>{
             if (!provider) {
                 return;
@@ -92,14 +135,58 @@ export class OpenTelemetryClient {
             this.traceProvider instanceof NodeTracerProvider ? flushAndShutdown(this.traceProvider) : Promise.resolve()
         ]);
     }
-    static createMeterProvider(resource, options) {
+    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: options.exporter ? [
-                new PeriodicExportingMetricReader(options)
-            ] : [],
+            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',
@@ -283,6 +370,61 @@ export class OpenTelemetryClient {
                         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)
                 })
             ]
         });
@@ -292,21 +434,59 @@ export class OpenTelemetryClient {
             const tracerProvider = new NodeTracerProvider({
                 resource,
                 spanProcessors: config.tracesCollectorUrl ? [
-                    new BatchSpanProcessor(new OTLPTraceExporter({
+                    new MonitoredBatchSpanProcessor(new OTLPTraceExporter({
                         url: config.tracesCollectorUrl.href
-                    }))
+                    }), log, {
+                        maxQueueSize: config.otelBspMaxQueueSize,
+                        minTraceDurationMs: config.otelMinTraceDurationMs
+                    })
                 ] : []
             });
-            tracerProvider.register();
-            const meterProvider = OpenTelemetryClient.createMeterProvider(resource, {
-                exporter: config.metricsCollectorUrl ? new OtelFilterMetricExporter(new OTLPMetricExporter({
-                    url: config.metricsCollectorUrl.href
-                }), config.otelExcludeMetrics ?? []) : undefined,
-                exportTimeoutMillis: config.otelExportTimeoutMs,
-                exportIntervalMillis: config.otelCollectIntervalMs
+            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, log);
+            return new OpenTelemetryClient(resource, meterProvider, tracerProvider, loggerProvider, publicExporter, log);
         };
     }
     static createAndStart(config, log) {

package/dest/otel_filter_metric_exporter.d.ts

@@ -1,12 +1,20 @@
-import type { ExportResult } from '@opentelemetry/core';
+import { type ExportResult } from '@opentelemetry/core';
 import type { PushMetricExporter, ResourceMetrics } from '@opentelemetry/sdk-metrics';
 export declare class OtelFilterMetricExporter implements PushMetricExporter {
     private readonly exporter;
-    private readonly excludeMetricPrefixes;
-    constructor(exporter: PushMetricExporter, excludeMetricPrefixes: string[]);
+    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;
 }
-//# sourceMappingURL=otel_filter_metric_exporter.d.ts.map
+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

@@ -1 +1 @@
-{"version":3,"file":"otel_filter_metric_exporter.d.ts","sourceRoot":"","sources":["../src/otel_filter_metric_exporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAc,kBAAkB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElG,qBAAa,wBAAyB,YAAW,kBAAkB;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAAsB,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAApE,QAAQ,EAAE,kBAAkB,EAAmB,qBAAqB,EAAE,MAAM,EAAE;IASpG,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI;IAW7F,OAAO,CAAC,aAAa;IAMd,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGjC"}
+{"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

@@ -1,9 +1,13 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import { AZTEC_NODE_ROLE } from './attributes.js';
 export class OtelFilterMetricExporter {
     exporter;
-    excludeMetricPrefixes;
-    constructor(exporter, excludeMetricPrefixes){
+    metricPrefix;
+    filter;
+    constructor(exporter, metricPrefix, filter = 'deny'){
         this.exporter = exporter;
-        this.excludeMetricPrefixes = excludeMetricPrefixes;
+        this.metricPrefix = metricPrefix;
+        this.filter = filter;
         if (exporter.selectAggregation) {
             this.selectAggregation = exporter.selectAggregation.bind(exporter);
         }
@@ -22,7 +26,15 @@ export class OtelFilterMetricExporter {
         this.exporter.export(filteredMetrics, resultCallback);
     }
     filterMetrics(metrics) {
-        return metrics.filter((metric)=>!this.excludeMetricPrefixes.some((prefix)=>metric.descriptor.name.startsWith(prefix)));
+        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();
@@ -30,4 +42,26 @@ export class OtelFilterMetricExporter {
     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

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

package/dest/otel_propagation.d.ts

@@ -1,3 +1,5 @@
+import type { DiagnosticsMiddleware } from '@aztec/foundation/json-rpc/server';
 import type Koa from 'koa';
 export declare function getOtelJsonRpcPropagationMiddleware(scope?: string): (ctx: Koa.Context, next: () => Promise<void>) => Promise<void>;
-//# sourceMappingURL=otel_propagation.d.ts.map
+export declare function getOtelJsonRpcDiagnosticsMiddleware(): DiagnosticsMiddleware;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RlbF9wcm9wYWdhdGlvbi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL290ZWxfcHJvcGFnYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUcvRSxPQUFPLEtBQUssR0FBRyxNQUFNLEtBQUssQ0FBQztBQVUzQix3QkFBZ0IsbUNBQW1DLENBQ2pELEtBQUssU0FBa0IsR0FDdEIsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9DaEU7QUFFRCx3QkFBZ0IsbUNBQW1DLElBQUkscUJBQXFCLENBNEIzRSJ9

package/dest/otel_propagation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"otel_propagation.d.ts","sourceRoot":"","sources":["../src/otel_propagation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAU3B,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,CAoChE"}
+{"version":3,"file":"otel_propagation.d.ts","sourceRoot":"","sources":["../src/otel_propagation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAG/E,OAAO,KAAK,GAAG,MAAM,KAAK,CAAC;AAU3B,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,CAoChE;AAED,wBAAgB,mCAAmC,IAAI,qBAAqB,CA4B3E"}

package/dest/otel_propagation.js

@@ -6,7 +6,7 @@ export function getOtelJsonRpcPropagationMiddleware(scope = 'JsonRpcServer') {
         const tracer = getTelemetryClient().getTracer(scope);
         const context = propagation.extract(ROOT_CONTEXT, ctx.request.headers);
         const method = ctx.request.body?.method;
-        return tracer.startActiveSpan(`JsonRpcServer.${method ?? 'unknown'}`, {
+        return tracer.startActiveSpan(`JsonRpcServer.${method ?? 'batch'}`, {
             kind: SpanKind.SERVER
         }, context, async (span)=>{
             if (ctx.id) {
@@ -42,3 +42,51 @@ export function getOtelJsonRpcPropagationMiddleware(scope = 'JsonRpcServer') {
         });
     };
 }
+export function getOtelJsonRpcDiagnosticsMiddleware() {
+    return function otelJsonRpcDiagnostics(ctx, next) {
+        const [namespace, method] = splitNamespace(ctx.method);
+        const scope = namespace ?? 'UnknownHandler';
+        const tracer = getTelemetryClient().getTracer(scope);
+        return tracer.startActiveSpan(`${scope}.${method}`, {
+            kind: SpanKind.INTERNAL,
+            attributes: {
+                [ATTR_JSONRPC_METHOD]: ctx.method
+            }
+        }, async (span)=>{
+            if (ctx.id !== null) {
+                span.setAttribute(ATTR_JSONRPC_REQUEST_ID, ctx.id);
+            }
+            try {
+                await next();
+                span.setStatus({
+                    code: SpanStatusCode.OK
+                });
+            } catch (err) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: err instanceof Error ? err.message : String(err)
+                });
+                if (typeof err === 'string' || err instanceof Error) {
+                    span.recordException(err);
+                }
+                throw err;
+            } finally{
+                span.end();
+            }
+        });
+    };
+}
+function splitNamespace(fullMethod) {
+    const idx = fullMethod.indexOf('_');
+    if (idx > -1) {
+        return [
+            fullMethod.slice(0, idx),
+            fullMethod.slice(idx + 1)
+        ];
+    } else {
+        return [
+            undefined,
+            fullMethod
+        ];
+    }
+}

package/dest/otel_resource.d.ts

@@ -1,3 +1,3 @@
 import { type IResource } from '@opentelemetry/resources';
 export declare function getOtelResource(): IResource;
-//# sourceMappingURL=otel_resource.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RlbF9yZXNvdXJjZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL290ZWxfcmVzb3VyY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUVMLEtBQUssU0FBUyxFQU1mLE1BQU0sMEJBQTBCLENBQUM7QUFxQmxDLHdCQUFnQixlQUFlLElBQUksU0FBUyxDQWUzQyJ9

package/dest/otel_resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"otel_resource.d.ts","sourceRoot":"","sources":["../src/otel_resource.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAMf,MAAM,0BAA0B,CAAC;AAElC,wBAAgB,eAAe,IAAI,SAAS,CAM3C"}
+{"version":3,"file":"otel_resource.d.ts","sourceRoot":"","sources":["../src/otel_resource.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,0BAA0B,CAAC;AAqBlC,wBAAgB,eAAe,IAAI,SAAS,CAe3C"}

package/dest/otel_resource.js

@@ -1,12 +1,53 @@
-import { detectResourcesSync, envDetectorSync, osDetectorSync, processDetectorSync, serviceInstanceIdDetectorSync } from '@opentelemetry/resources';
+import { Resource, detectResourcesSync, envDetectorSync, osDetectorSync, serviceInstanceIdDetectorSync } from '@opentelemetry/resources';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { AZTEC_NODE_ROLE, AZTEC_REGISTRY_ADDRESS, AZTEC_ROLLUP_ADDRESS, AZTEC_ROLLUP_VERSION } from './attributes.js';
+/** Reads the Aztec client version from the release manifest. */ function getAztecVersion() {
+    try {
+        const releasePleasePath = resolve(dirname(fileURLToPath(import.meta.url)), '../../../.release-please-manifest.json');
+        return JSON.parse(readFileSync(releasePleasePath, 'utf-8'))['.'];
+    } catch  {
+        return undefined;
+    }
+}
 export function getOtelResource() {
     const resource = detectResourcesSync({
         detectors: [
+            aztecNetworkDetectorSync,
             osDetectorSync,
             envDetectorSync,
-            processDetectorSync,
+            // this detector is disabled because:
+            // 1. our software runs in a docker container, a lot of the attributes detected would be identical across different machines (e.g. all run node v22, executing the same script, running PID 1, etc)
+            // 2. it catures process.argv which could contain sensitive values in plain text (e.g. validator private keys)
+            // processDetectorSync,
             serviceInstanceIdDetectorSync
         ]
     });
     return resource;
 }
+const aztecNetworkDetectorSync = {
+    detect () {
+        let role;
+        if (process.argv.includes('--sequencer')) {
+            role = 'sequencer';
+        } else if (process.argv.includes('--prover-node')) {
+            role = 'prover-node';
+        } else if (process.argv.includes('--node')) {
+            role = 'node';
+        } else if (process.argv.includes('--p2p-bootstrap')) {
+            role = 'bootnode';
+        }
+        const aztecAttributes = {
+            // this gets overwritten by OTEL_RESOURCE_ATTRIBUTES (if set)
+            [ATTR_SERVICE_NAME]: role ? `aztec-${role}` : undefined,
+            [ATTR_SERVICE_VERSION]: getAztecVersion(),
+            [AZTEC_NODE_ROLE]: role,
+            [AZTEC_ROLLUP_VERSION]: process.env.ROLLUP_VERSION ?? 'canonical',
+            [AZTEC_ROLLUP_ADDRESS]: process.env.ROLLUP_CONTRACT_ADDRESS,
+            [AZTEC_REGISTRY_ADDRESS]: process.env.REGISTRY_CONTRACT_ADDRESS
+        };
+        return new Resource(aztecAttributes);
+    }
+};

package/dest/prom_otel_adapter.d.ts

@@ -1,4 +1,4 @@
-import { type Logger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings } from '@aztec/foundation/log';
 import { Registry } from 'prom-client';
 import type { Meter, TelemetryClient } from './telemetry.js';
 /**
@@ -97,18 +97,67 @@ export declare class OtelGauge<Labels extends LabelsGeneric = NoLabels> implemen
      * Resets the gauge to initial state
      */
     reset(): void;
+}
+/**
+ * Implementation of a Histogram collector
+ */
+export declare class OtelHistogram<Labels extends LabelsGeneric = NoLabels> implements IHistogram<Labels> {
+    private logger;
+    private labelNames;
+    private histogram;
+    constructor(logger: Logger, meter: Meter, name: string, help: string, buckets?: number[], labelNames?: Array<keyof Labels>);
+    /**
+     * Starts a timer and returns a function that when called will record the time elapsed
+     * @param labels - Optional labels for the observation
+     */
+    startTimer(labels?: Labels): () => void;
+    /**
+     * Observes a value
+     * @param value - Value to observe
+     */
+    observe(value: number): void;
+    /**
+     * Observes a value with labels
+     * @param labels - Labels object
+     * @param value - Value to observe
+     */
+    observe(labels: Labels, value: number): void;
+    reset(): void;
+}
+/**
+ * Implementation of an AvgMinMax collector
+ */
+export declare class OtelAvgMinMax<Labels extends LabelsGeneric = NoLabels> implements IAvgMinMax<Labels> {
+    private logger;
+    private labelNames;
+    private gauges;
+    private currentValues;
+    private labeledValues;
+    constructor(logger: Logger, meter: Meter, name: string, help: string, labelNames?: Array<keyof Labels>);
     /**
-     * Validates that provided labels match the expected schema
-     * @param labels - Labels object to validate
-     * @throws Error if invalid labels are provided
+     * Sets the values for calculating avg, min, max
+     * @param values - Array of values
      */
-    private validateLabels;
+    set(values: number[]): void;
     /**
-     * Safely parses label string back to object
-     * @param labelStr - Stringified labels object
-     * @returns Labels object or null if parsing fails
+     * Sets the values for calculating avg, min, max with labels
+     * @param labels - Labels object
+     * @param values - Array of values
      */
-    private parseLabelsSafely;
+    set(labels: Labels, values: number[]): void;
+    /**
+     * Resets all stored values
+     */
+    reset(): void;
+    /**
+     * General function to observe an aggregation
+     * @param result - Observer result
+     * @param aggregateFn - Function that calculates the aggregation
+     */
+    private observeAggregation;
+    private observeAvg;
+    private observeMin;
+    private observeMax;
 }
 /**
  * Otel metrics Adapter
@@ -116,12 +165,12 @@ export declare class OtelGauge<Labels extends LabelsGeneric = NoLabels> implemen
  * Maps the PromClient based MetricsRegister from gossipsub and discv5 services to the Otel MetricsRegister
  */
 export declare class OtelMetricsAdapter extends Registry implements MetricsRegister {
-    private logger;
     private readonly meter;
-    constructor(telemetryClient: TelemetryClient, logger?: Logger);
+    private logger;
+    constructor(telemetryClient: TelemetryClient, bindings?: LoggerBindings);
     gauge<Labels extends LabelsGeneric = NoLabels>(configuration: GaugeConfig<Labels>): IGauge<Labels>;
     histogram<Labels extends LabelsGeneric = NoLabels>(configuration: HistogramConfig<Labels>): IHistogram<Labels>;
     avgMinMax<Labels extends LabelsGeneric = NoLabels>(configuration: AvgMinMaxConfig<Labels>): IAvgMinMax<Labels>;
 }
 export {};
-//# sourceMappingURL=prom_otel_adapter.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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