@aztec/telemetry-client 0.0.0-test.0

package/src/bench.ts

@@ -0,0 +1,147 @@
+import type { BatchObservableCallback, Context, MetricOptions, Observable, ValueType } from '@opentelemetry/api';
+
+import { NoopTracer } from './noop.js';
+import type {
+  AttributesType,
+  Gauge,
+  Histogram,
+  Meter,
+  MetricsType,
+  ObservableGauge,
+  ObservableUpDownCounter,
+  TelemetryClient,
+  Tracer,
+  UpDownCounter,
+} from './telemetry.js';
+
+export type BenchmarkMetricsType = {
+  name: string;
+  metrics: {
+    name: string;
+    type: 'gauge' | 'counter' | 'histogram';
+    description?: string;
+    unit?: string;
+    valueType?: ValueType;
+    points: BenchmarkDataPoint[];
+  }[];
+}[];
+
+export class BenchmarkTelemetryClient implements TelemetryClient {
+  private meters: InMemoryPlainMeter[] = [];
+
+  getMeter(name: string): Meter {
+    const meter = new InMemoryPlainMeter(name);
+    this.meters.push(meter);
+    return meter;
+  }
+
+  getTracer(): Tracer {
+    return new NoopTracer();
+  }
+
+  stop(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  flush(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  isEnabled() {
+    return true;
+  }
+
+  getMeters(): BenchmarkMetricsType {
+    return this.meters;
+  }
+
+  clear() {
+    this.meters.forEach(meter => meter.clear());
+  }
+}
+
+class InMemoryPlainMeter implements Meter {
+  public readonly metrics: InMemoryPlainMetric[] = [];
+
+  constructor(public readonly name: string) {}
+
+  clear() {
+    this.metrics.forEach(metric => metric.clear());
+  }
+
+  createGauge(name: MetricsType, options?: MetricOptions | undefined): Gauge {
+    return this.createMetric('gauge', name, options);
+  }
+
+  createObservableGauge(name: MetricsType, options?: MetricOptions | undefined): ObservableGauge {
+    return this.createMetric('gauge', name, options);
+  }
+
+  createHistogram(name: MetricsType, options?: MetricOptions | undefined): Histogram {
+    return this.createMetric('histogram', name, options);
+  }
+
+  createUpDownCounter(name: MetricsType, options?: MetricOptions | undefined): UpDownCounter {
+    return this.createMetric('counter', name, options);
+  }
+
+  createObservableUpDownCounter(name: MetricsType, options?: MetricOptions | undefined): ObservableUpDownCounter {
+    return this.createMetric('counter', name, options);
+  }
+
+  private createMetric(type: 'gauge' | 'counter' | 'histogram', name: string, options?: MetricOptions) {
+    const metric = new InMemoryPlainMetric(type, name, options);
+    this.metrics.push(metric);
+    return metric;
+  }
+
+  addBatchObservableCallback(
+    _callback: BatchObservableCallback<AttributesType>,
+    _observables: Observable<AttributesType>[],
+  ): void {}
+
+  removeBatchObservableCallback(
+    _callback: BatchObservableCallback<AttributesType>,
+    _observables: Observable<AttributesType>[],
+  ): void {}
+}
+
+export type BenchmarkDataPoint = { value: number; attributes?: AttributesType; context?: Context };
+
+class InMemoryPlainMetric {
+  public readonly points: BenchmarkDataPoint[] = [];
+
+  public readonly description?: string;
+  public readonly unit?: string;
+  public readonly valueType?: ValueType;
+
+  constructor(
+    public readonly type: 'gauge' | 'counter' | 'histogram',
+    public readonly name: string,
+    options?: MetricOptions,
+  ) {
+    this.description = options?.description;
+    this.unit = options?.unit;
+    this.valueType = options?.valueType;
+  }
+
+  add(value: number, attributes?: AttributesType, context?: Context): void {
+    this.points.push({ value, attributes, context });
+  }
+
+  record(value: number, attributes?: AttributesType, context?: Context): void {
+    this.points.push({ value, attributes, context });
+  }
+
+  addCallback() {}
+
+  removeCallback() {}
+
+  getPoints(): BenchmarkDataPoint[] {
+    return this.points;
+  }
+
+  clear() {
+    this.points.splice(0, this.points.length);
+  }
+}

package/src/config.ts

@@ -0,0 +1,56 @@
+import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+
+export interface TelemetryClientConfig {
+  metricsCollectorUrl?: URL;
+  tracesCollectorUrl?: URL;
+  logsCollectorUrl?: URL;
+  otelCollectIntervalMs: number;
+  otelExportTimeoutMs: number;
+  otelExcludeMetrics?: string[];
+}
+
+export const telemetryClientConfigMappings: ConfigMappingsType<TelemetryClientConfig> = {
+  metricsCollectorUrl: {
+    env: 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT',
+    description: 'The URL of the telemetry collector for metrics',
+    parseEnv: (val: string) => val && new URL(val),
+  },
+  tracesCollectorUrl: {
+    env: 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT',
+    description: 'The URL of the telemetry collector for traces',
+    parseEnv: (val: string) => val && new URL(val),
+  },
+  logsCollectorUrl: {
+    env: 'OTEL_EXPORTER_OTLP_LOGS_ENDPOINT',
+    description: 'The URL of the telemetry collector for logs',
+    parseEnv: (val: string) => val && new URL(val),
+  },
+  otelCollectIntervalMs: {
+    env: 'OTEL_COLLECT_INTERVAL_MS',
+    description: 'The interval at which to collect metrics',
+    defaultValue: 60000, // Default extracted from otel client
+    parseEnv: (val: string) => parseInt(val),
+  },
+  otelExportTimeoutMs: {
+    env: 'OTEL_EXPORT_TIMEOUT_MS',
+    description: 'The timeout for exporting metrics',
+    defaultValue: 30000, // Default extracted from otel client
+    parseEnv: (val: string) => parseInt(val),
+  },
+  otelExcludeMetrics: {
+    env: 'OTEL_EXCLUDE_METRICS',
+    description: 'A list of metric prefixes to exclude from export',
+    parseEnv: (val: string) =>
+      val
+        ? val
+            .split(',')
+            .map(s => s.trim())
+            .filter(s => s.length > 0)
+        : [],
+    defaultValue: [],
+  },
+};
+
+export function getConfigEnvVars(): TelemetryClientConfig {
+  return getConfigFromMappings<TelemetryClientConfig>(telemetryClientConfigMappings);
+}

package/src/event_loop_monitor.ts

@@ -0,0 +1,119 @@
+import { type EventLoopUtilization, type IntervalHistogram, monitorEventLoopDelay, performance } from 'node:perf_hooks';
+
+import * as Attributes from './attributes.js';
+import * as Metrics from './metrics.js';
+import {
+  type BatchObservableResult,
+  type Meter,
+  type ObservableGauge,
+  type UpDownCounter,
+  ValueType,
+} from './telemetry.js';
+
+/**
+ * Detector for custom Aztec attributes
+ */
+export class EventLoopMonitor {
+  private eventLoopDelayGauges: {
+    min: ObservableGauge;
+    max: ObservableGauge;
+    mean: ObservableGauge;
+    stddev: ObservableGauge;
+    p50: ObservableGauge;
+    p90: ObservableGauge;
+    p99: ObservableGauge;
+  };
+
+  private eventLoopUilization: ObservableGauge;
+  private eventLoopTime: UpDownCounter;
+
+  private started = false;
+
+  private lastELU: EventLoopUtilization | undefined;
+  private eventLoopDelay: IntervalHistogram;
+
+  constructor(private meter: Meter) {
+    const nsObsGauge = (name: (typeof Metrics)[keyof typeof Metrics], description: string) =>
+      meter.createObservableGauge(name, {
+        unit: 'ns',
+        valueType: ValueType.INT,
+        description,
+      });
+
+    this.eventLoopDelayGauges = {
+      min: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MIN, 'Minimum delay of the event loop'),
+      mean: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MEAN, 'Mean delay of the event loop'),
+      max: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MAX, 'Max delay of the event loop'),
+      stddev: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_STDDEV, 'Stddev delay of the event loop'),
+      p50: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P50, 'P50 delay of the event loop'),
+      p90: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P90, 'P90 delay of the event loop'),
+      p99: nsObsGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P99, 'P99 delay of the event loop'),
+    };
+
+    this.eventLoopUilization = meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_UTILIZATION, {
+      valueType: ValueType.DOUBLE,
+      description: 'How busy is the event loop',
+    });
+
+    this.eventLoopTime = meter.createUpDownCounter(Metrics.NODEJS_EVENT_LOOP_TIME, {
+      unit: 'ms',
+      valueType: ValueType.INT,
+      description: 'How much time the event loop has spent in a given state',
+    });
+
+    this.eventLoopDelay = monitorEventLoopDelay();
+  }
+
+  start(): void {
+    if (this.started) {
+      return;
+    }
+
+    this.lastELU = performance.eventLoopUtilization();
+    this.eventLoopDelay.enable();
+    this.meter.addBatchObservableCallback(this.measure, [
+      this.eventLoopUilization,
+      ...Object.values(this.eventLoopDelayGauges),
+    ]);
+  }
+
+  stop(): void {
+    if (!this.started) {
+      return;
+    }
+    this.meter.removeBatchObservableCallback(this.measure, [
+      this.eventLoopUilization,
+      ...Object.values(this.eventLoopDelayGauges),
+    ]);
+    this.eventLoopDelay.disable();
+    this.eventLoopDelay.reset();
+    this.lastELU = undefined;
+  }
+
+  private measure = (obs: BatchObservableResult): void => {
+    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.floor(delta.idle), { [Attributes.NODEJS_EVENT_LOOP_STATE]: 'idle' });
+    this.eventLoopTime.add(Math.floor(delta.active), { [Attributes.NODEJS_EVENT_LOOP_STATE]: 'active' });
+
+    obs.observe(this.eventLoopDelayGauges.min, Math.floor(this.eventLoopDelay.min));
+    obs.observe(this.eventLoopDelayGauges.mean, Math.floor(this.eventLoopDelay.mean));
+    obs.observe(this.eventLoopDelayGauges.max, Math.floor(this.eventLoopDelay.max));
+    obs.observe(this.eventLoopDelayGauges.stddev, Math.floor(this.eventLoopDelay.stddev));
+    obs.observe(this.eventLoopDelayGauges.p50, Math.floor(this.eventLoopDelay.percentile(50)));
+    obs.observe(this.eventLoopDelayGauges.p90, Math.floor(this.eventLoopDelay.percentile(90)));
+    obs.observe(this.eventLoopDelayGauges.p99, Math.floor(this.eventLoopDelay.percentile(99)));
+
+    this.eventLoopDelay.reset();
+  };
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './telemetry.js';
+export * as Metrics from './metrics.js';
+export * as Attributes from './attributes.js';
+export * from './with_tracer.js';
+export * from './prom_otel_adapter.js';
+export * from './lmdb_metrics.js';
+export * from './wrappers/index.js';
+export * from './start.js';
+export * from './otel_propagation.js';

package/src/lmdb_metrics.ts

@@ -0,0 +1,45 @@
+import * as Metrics from './metrics.js';
+import {
+  type AttributesType,
+  type BatchObservableResult,
+  type Meter,
+  type ObservableGauge,
+  ValueType,
+} from './telemetry.js';
+
+export type LmdbStatsCallback = () => Promise<{ mappingSize: number; numItems: number; actualSize: number }>;
+
+export class LmdbMetrics {
+  private dbMapSize: ObservableGauge;
+  private dbUsedSize: ObservableGauge;
+  private dbNumItems: ObservableGauge;
+
+  constructor(meter: Meter, private attributes?: AttributesType, private getStats?: LmdbStatsCallback) {
+    this.dbMapSize = meter.createObservableGauge(Metrics.DB_MAP_SIZE, {
+      description: 'LMDB Map Size',
+      valueType: ValueType.INT,
+      unit: 'By',
+    });
+    this.dbUsedSize = meter.createObservableGauge(Metrics.DB_USED_SIZE, {
+      description: 'LMDB Used Size',
+      valueType: ValueType.INT,
+      unit: 'By',
+    });
+    this.dbNumItems = meter.createObservableGauge(Metrics.DB_NUM_ITEMS, {
+      description: 'LMDB Num Items',
+      valueType: ValueType.INT,
+    });
+
+    meter.addBatchObservableCallback(this.recordDBMetrics, [this.dbMapSize, this.dbUsedSize, this.dbNumItems]);
+  }
+
+  private recordDBMetrics = async (observable: BatchObservableResult) => {
+    if (!this.getStats) {
+      return;
+    }
+    const metrics = await this.getStats();
+    observable.observe(this.dbMapSize, metrics.mappingSize, this.attributes);
+    observable.observe(this.dbNumItems, metrics.numItems, this.attributes);
+    observable.observe(this.dbUsedSize, metrics.actualSize, this.attributes);
+  };
+}

package/src/metrics.ts

@@ -0,0 +1,153 @@
+/**
+ * @file Metric names used in Aztec.
+ * Metric names must be unique and not clash with {@link attributes.ts | Attribute names}.
+ * Prefix metric names with `aztec` and use dots `.` to separate namespaces.
+ *
+ * @see {@link https://opentelemetry.io/docs/specs/semconv/general/metrics/ | OpenTelemetry Metrics} for naming conventions.
+ */
+
+export const BLOB_SINK_OBJECTS_IN_BLOB_STORE = 'aztec.blob_sink.objects_in_blob_store';
+export const BLOB_SINK_BLOB_SIZE = 'aztec.blob_sink.blob_size';
+
+/** How long it takes to simulate a circuit */
+export const CIRCUIT_SIMULATION_DURATION = 'aztec.circuit.simulation.duration';
+export const CIRCUIT_SIMULATION_INPUT_SIZE = 'aztec.circuit.simulation.input_size';
+export const CIRCUIT_SIMULATION_OUTPUT_SIZE = 'aztec.circuit.simulation.output_size';
+
+export const CIRCUIT_WITNESS_GEN_DURATION = 'aztec.circuit.witness_generation.duration';
+export const CIRCUIT_WITNESS_GEN_INPUT_SIZE = 'aztec.circuit.witness_generation.input_size';
+export const CIRCUIT_WITNESS_GEN_OUTPUT_SIZE = 'aztec.circuit.witness_generation.output_size';
+
+export const CIRCUIT_PROVING_DURATION = 'aztec.circuit.proving.duration';
+export const CIRCUIT_PROVING_INPUT_SIZE = 'aztec.circuit.proving.input_size';
+export const CIRCUIT_PROVING_PROOF_SIZE = 'aztec.circuit.proving.proof_size';
+
+export const CIRCUIT_PUBLIC_INPUTS_COUNT = 'aztec.circuit.public_inputs_count';
+export const CIRCUIT_GATE_COUNT = 'aztec.circuit.gate_count';
+export const CIRCUIT_SIZE = 'aztec.circuit.size';
+
+export const MEMPOOL_TX_COUNT = 'aztec.mempool.tx_count';
+export const MEMPOOL_TX_SIZE = 'aztec.mempool.tx_size';
+export const DB_NUM_ITEMS = 'aztec.db.num_items';
+export const DB_MAP_SIZE = 'aztec.db.map_size';
+export const DB_USED_SIZE = 'aztec.db.used_size';
+
+export const MEMPOOL_ATTESTATIONS_COUNT = 'aztec.mempool.attestations_count';
+export const MEMPOOL_ATTESTATIONS_SIZE = 'aztec.mempool.attestations_size';
+
+export const ARCHIVER_SYNC_DURATION = 'aztec.archiver.sync_duration';
+export const ARCHIVER_L1_BLOCKS_SYNCED = 'aztec.archiver.l1_blocks_synced';
+export const ARCHIVER_L1_BLOCK_HEIGHT = 'aztec.archiver.l1_block_height';
+export const ARCHIVER_BLOCK_HEIGHT = 'aztec.archiver.block_height';
+export const ARCHIVER_TX_COUNT = 'aztec.archiver.tx_count';
+export const ARCHIVER_ROLLUP_PROOF_DELAY = 'aztec.archiver.rollup_proof_delay';
+export const ARCHIVER_ROLLUP_PROOF_COUNT = 'aztec.archiver.rollup_proof_count';
+export const ARCHIVER_PRUNE_COUNT = 'aztec.archiver.prune_count';
+
+export const NODE_RECEIVE_TX_DURATION = 'aztec.node.receive_tx.duration';
+export const NODE_RECEIVE_TX_COUNT = 'aztec.node.receive_tx.count';
+
+export const SEQUENCER_STATE_TRANSITION_BUFFER_DURATION = 'aztec.sequencer.state_transition_buffer.duration';
+export const SEQUENCER_BLOCK_BUILD_DURATION = 'aztec.sequencer.block.build_duration';
+export const SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND = 'aztec.sequencer.block.build_mana_per_second';
+export const SEQUENCER_BLOCK_COUNT = 'aztec.sequencer.block.count';
+export const SEQUENCER_CURRENT_STATE = 'aztec.sequencer.current.state';
+export const SEQUENCER_CURRENT_BLOCK_NUMBER = 'aztec.sequencer.current.block_number';
+export const SEQUENCER_CURRENT_BLOCK_SIZE = 'aztec.sequencer.current.block_size';
+export const SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS = 'aztec.sequencer.time_to_collect_attestations';
+export const SEQUENCER_BLOCK_BUILD_INSERTION_TIME = 'aztec.sequencer.block_builder_tree_insertion_duration';
+
+export const L1_PUBLISHER_GAS_PRICE = 'aztec.l1_publisher.gas_price';
+export const L1_PUBLISHER_TX_COUNT = 'aztec.l1_publisher.tx_count';
+export const L1_PUBLISHER_TX_DURATION = 'aztec.l1_publisher.tx_duration';
+export const L1_PUBLISHER_TX_GAS = 'aztec.l1_publisher.tx_gas';
+export const L1_PUBLISHER_TX_CALLDATA_SIZE = 'aztec.l1_publisher.tx_calldata_size';
+export const L1_PUBLISHER_TX_CALLDATA_GAS = 'aztec.l1_publisher.tx_calldata_gas';
+export const L1_PUBLISHER_TX_BLOBDATA_GAS_USED = 'aztec.l1_publisher.tx_blobdata_gas_used';
+export const L1_PUBLISHER_TX_BLOBDATA_GAS_COST = 'aztec.l1_publisher.tx_blobdata_gas_cost';
+export const L1_PUBLISHER_BLOB_COUNT = 'aztec.l1_publisher.blob_count';
+export const L1_PUBLISHER_BLOB_INCLUSION_BLOCKS = 'aztec.l1_publisher.blob_inclusion_blocks';
+export const L1_PUBLISHER_BLOB_TX_SUCCESS = 'aztec.l1_publisher.blob_tx_success';
+export const L1_PUBLISHER_BLOB_TX_FAILURE = 'aztec.l1_publisher.blob_tx_failure';
+export const L1_PUBLISHER_BALANCE = 'aztec.l1_publisher.balance';
+
+export const PEER_MANAGER_GOODBYES_SENT = 'aztec.peer_manager.goodbyes_sent';
+export const PEER_MANAGER_GOODBYES_RECEIVED = 'aztec.peer_manager.goodbyes_received';
+
+export const P2P_REQ_RESP_SENT_REQUESTS = 'aztec.p2p.req_resp.sent_requests';
+export const P2P_REQ_RESP_RECEIVED_REQUESTS = 'aztec.p2p.req_resp.received_requests';
+export const P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS = 'aztec.p2p.req_resp.failed_outbound_requests';
+export const P2P_REQ_RESP_FAILED_INBOUND_REQUESTS = 'aztec.p2p.req_resp.failed_inbound_requests';
+
+export const PUBLIC_PROCESSOR_TX_DURATION = 'aztec.public_processor.tx_duration';
+export const PUBLIC_PROCESSOR_TX_COUNT = 'aztec.public_processor.tx_count';
+export const PUBLIC_PROCESSOR_TX_PHASE_COUNT = 'aztec.public_processor.tx_phase_count';
+export const PUBLIC_PROCESSOR_TX_GAS = 'aztec.public_processor.tx_gas';
+export const PUBLIC_PROCESSOR_PHASE_DURATION = 'aztec.public_processor.phase_duration';
+export const PUBLIC_PROCESSOR_PHASE_COUNT = 'aztec.public_processor.phase_count';
+export const PUBLIC_PROCESSOR_DEPLOY_BYTECODE_SIZE = 'aztec.public_processor.deploy_bytecode_size';
+export const PUBLIC_PROCESSOR_TOTAL_GAS = 'aztec.public_processor.total_gas';
+export const PUBLIC_PROCESSOR_TOTAL_GAS_HISTOGRAM = 'aztec.public_processor.total_gas_histogram';
+export const PUBLIC_PROCESSOR_GAS_RATE = 'aztec.public_processor.gas_rate';
+export const PUBLIC_PROCESSOR_TREE_INSERTION = 'aztec.public_processor.tree_insertion';
+
+export const PUBLIC_EXECUTOR_SIMULATION_COUNT = 'aztec.public_executor.simulation_count';
+export const PUBLIC_EXECUTOR_SIMULATION_DURATION = 'aztec.public_executor.simulation_duration';
+export const PUBLIC_EXECUTOR_SIMULATION_MANA_PER_SECOND = 'aztec.public_executor.simulation_mana_per_second';
+export const PUBLIC_EXECUTION_SIMULATION_BYTECODE_SIZE = 'aztec.public_executor.simulation_bytecode_size';
+export const PUBLIC_EXECUTION_PRIVATE_EFFECTS_INSERTION = 'aztec.public_executor.private_effects_insertion';
+
+export const PROVING_ORCHESTRATOR_BASE_ROLLUP_INPUTS_DURATION =
+  'aztec.proving_orchestrator.base_rollup.inputs_duration';
+
+export const PROVING_QUEUE_JOB_SIZE = 'aztec.proving_queue.job_size';
+export const PROVING_QUEUE_SIZE = 'aztec.proving_queue.size';
+export const PROVING_QUEUE_TOTAL_JOBS = 'aztec.proving_queue.enqueued_jobs_count';
+export const PROVING_QUEUE_CACHED_JOBS = 'aztec.proving_queue.cached_jobs_count';
+export const PROVING_QUEUE_ACTIVE_JOBS = 'aztec.proving_queue.active_jobs_count';
+export const PROVING_QUEUE_RESOLVED_JOBS = 'aztec.proving_queue.resolved_jobs_count';
+export const PROVING_QUEUE_REJECTED_JOBS = 'aztec.proving_queue.rejected_jobs_count';
+export const PROVING_QUEUE_RETRIED_JOBS = 'aztec.proving_queue.retried_jobs_count';
+export const PROVING_QUEUE_TIMED_OUT_JOBS = 'aztec.proving_queue.timed_out_jobs_count';
+export const PROVING_QUEUE_JOB_WAIT = 'aztec.proving_queue.job_wait';
+export const PROVING_QUEUE_JOB_DURATION = 'aztec.proving_queue.job_duration';
+export const PROVING_QUEUE_DB_NUM_ITEMS = 'aztec.proving_queue.db.num_items';
+export const PROVING_QUEUE_DB_MAP_SIZE = 'aztec.proving_queue.db.map_size';
+export const PROVING_QUEUE_DB_USED_SIZE = 'aztec.proving_queue.db.used_size';
+
+export const PROVING_AGENT_IDLE = 'aztec.proving_queue.agent.idle';
+
+export const PROVER_NODE_EXECUTION_DURATION = 'aztec.prover_node.execution.duration';
+export const PROVER_NODE_JOB_DURATION = 'aztec.prover_node.job_duration';
+export const PROVER_NODE_JOB_BLOCKS = 'aztec.prover_node.job_blocks';
+export const PROVER_NODE_JOB_TRANSACTIONS = 'aztec.prover_node.job_transactions';
+
+export const WORLD_STATE_FORK_DURATION = 'aztec.world_state.fork.duration';
+export const WORLD_STATE_SYNC_DURATION = 'aztec.world_state.sync.duration';
+export const WORLD_STATE_MERKLE_TREE_SIZE = 'aztec.world_state.merkle_tree_size';
+export const WORLD_STATE_DB_SIZE = 'aztec.world_state.db_size';
+export const WORLD_STATE_DB_MAP_SIZE = 'aztec.world_state.db_map_size';
+export const WORLD_STATE_TREE_SIZE = 'aztec.world_state.tree_size';
+export const WORLD_STATE_UNFINALISED_HEIGHT = 'aztec.world_state.unfinalised_height';
+export const WORLD_STATE_FINALISED_HEIGHT = 'aztec.world_state.finalised_height';
+export const WORLD_STATE_OLDEST_BLOCK = 'aztec.world_state.oldest_block';
+export const WORLD_STATE_DB_USED_SIZE = 'aztec.world_state.db_used_size';
+export const WORLD_STATE_DB_NUM_ITEMS = 'aztec.world_state.db_num_items';
+export const WORLD_STATE_REQUEST_TIME = 'aztec.world_state.request_time';
+export const WORLD_STATE_CRITICAL_ERROR_COUNT = 'aztec.world_state.critical_error_count';
+
+export const PROOF_VERIFIER_COUNT = 'aztec.proof_verifier.count';
+
+export const VALIDATOR_RE_EXECUTION_TIME = 'aztec.validator.re_execution_time';
+export const VALIDATOR_FAILED_REEXECUTION_COUNT = 'aztec.validator.failed_reexecution_count';
+
+export const NODEJS_EVENT_LOOP_DELAY_MIN = 'nodejs.eventloop.delay.min';
+export const NODEJS_EVENT_LOOP_DELAY_MEAN = 'nodejs.eventloop.delay.mean';
+export const NODEJS_EVENT_LOOP_DELAY_MAX = 'nodejs.eventloop.delay.max';
+export const NODEJS_EVENT_LOOP_DELAY_STDDEV = 'nodejs.eventloop.delay.stddev';
+export const NODEJS_EVENT_LOOP_DELAY_P50 = 'nodejs.eventloop.delay.p50';
+export const NODEJS_EVENT_LOOP_DELAY_P90 = 'nodejs.eventloop.delay.p90';
+export const NODEJS_EVENT_LOOP_DELAY_P99 = 'nodejs.eventloop.delay.p99';
+
+export const NODEJS_EVENT_LOOP_UTILIZATION = 'nodejs.eventloop.utilization';
+export const NODEJS_EVENT_LOOP_TIME = 'nodejs.eventloop.time';

package/src/noop.ts

@@ -0,0 +1,91 @@
+import { type Meter, type Span, type SpanContext, type Tracer, createNoopMeter } from '@opentelemetry/api';
+
+import type { TelemetryClient } from './telemetry.js';
+
+export class NoopTelemetryClient implements TelemetryClient {
+  getMeter(): Meter {
+    return createNoopMeter();
+  }
+
+  getTracer(): Tracer {
+    return new NoopTracer();
+  }
+
+  stop(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  flush(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  isEnabled() {
+    return false;
+  }
+}
+
+// @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 implements Tracer {
+  startSpan(): Span {
+    return new NoopSpan();
+  }
+
+  startActiveSpan<F extends (...args: any[]) => any>(_name: string, ...args: (unknown | F)[]): ReturnType<F> {
+    // 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') as F;
+    return fn(new NoopSpan());
+  }
+}
+
+class NoopSpan implements Span {
+  private recording: boolean = true;
+  addEvent(): this {
+    return this;
+  }
+
+  addLink(): this {
+    return this;
+  }
+
+  addLinks(): this {
+    return this;
+  }
+
+  end(): void {
+    this.recording = false;
+  }
+
+  isRecording(): boolean {
+    return this.recording;
+  }
+
+  recordException(): void {
+    return;
+  }
+
+  setAttribute(): this {
+    return this;
+  }
+
+  setAttributes(): this {
+    return this;
+  }
+
+  setStatus(): this {
+    return this;
+  }
+
+  spanContext(): SpanContext {
+    return {
+      spanId: '',
+      traceId: '',
+      traceFlags: 0,
+    };
+  }
+
+  updateName(): this {
+    return this;
+  }
+}