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

package/dest/with_tracer.d.ts

@@ -0,0 +1,33 @@
+import type { TelemetryClient, Tracer } from './telemetry.js';
+/**
+ * A minimal class that enables recording metrics with a telemetry client.
+ * This base class enables tracing
+ *
+ * In other words:
+ * Enables the ability to call `@trackSpan` on methods.
+ *
+ * Example:
+ *
+ * ```
+ * import {Attributes, type TelemetryClient, WithTracer, trackSpan } from '@aztec-labs/telemetry-client';
+ *
+ * class MyClass extends WithTracer {
+ *   // Constructor is required to be passed the TelemetryClient implementation.
+ *   constructor(client: TelemetryClient) {
+ *     super(client, 'MyClass');
+ *   }
+ *
+ *   @trackSpan('MyClass.myMethod', (arg: string) => ({
+ *     [Attributes.ARG]: arg,
+ *   }))
+ *   public myMethod(arg: string) {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+export declare class WithTracer {
+    readonly tracer: Tracer;
+    constructor(client: TelemetryClient, name: string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aF90cmFjZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy93aXRoX3RyYWNlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFOUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMEJHO0FBQ0gscUJBQWEsVUFBVTtJQUNyQixTQUFnQixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQy9CLFlBQVksTUFBTSxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsTUFBTSxFQUVoRDtDQUNGIn0=

package/dest/with_tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with_tracer.d.ts","sourceRoot":"","sources":["../src/with_tracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,UAAU;IACrB,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,YAAY,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAEhD;CACF"}

package/dest/with_tracer.js

@@ -0,0 +1,32 @@
+/**
+ * A minimal class that enables recording metrics with a telemetry client.
+ * This base class enables tracing
+ *
+ * In other words:
+ * Enables the ability to call `@trackSpan` on methods.
+ *
+ * Example:
+ *
+ * ```
+ * import {Attributes, type TelemetryClient, WithTracer, trackSpan } from '@aztec-labs/telemetry-client';
+ *
+ * class MyClass extends WithTracer {
+ *   // Constructor is required to be passed the TelemetryClient implementation.
+ *   constructor(client: TelemetryClient) {
+ *     super(client, 'MyClass');
+ *   }
+ *
+ *   @trackSpan('MyClass.myMethod', (arg: string) => ({
+ *     [Attributes.ARG]: arg,
+ *   }))
+ *   public myMethod(arg: string) {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */ export class WithTracer {
+    tracer;
+    constructor(client, name){
+        this.tracer = client.getTracer(name);
+    }
+}

package/dest/wrappers/fetch.d.ts

@@ -0,0 +1,16 @@
+import { defaultFetch } from '@aztec-labs/foundation/json-rpc/client';
+import type { Logger } from '@aztec-labs/foundation/log';
+/**
+ * Makes a fetch function that retries based on the given attempts and propagates trace information.
+ * @param retries - Sequence of intervals (in seconds) to retry, or a factory function returning an iterator for custom/indefinite backoff.
+ * @param noRetry - Whether to stop retries on server errors.
+ * @param log - Optional logger for logging attempts.
+ * @returns A fetch function.
+ */
+export declare function makeTracedFetch(retries: number[] | (() => Generator<number>), defaultNoRetry: boolean, fetch?: typeof defaultFetch, log?: Logger): (host: string, body: unknown, extraHeaders?: Record<string, string>, noRetry?: boolean | undefined) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmV0Y2guZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93cmFwcGVycy9mZXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDdEUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFPekQ7Ozs7OztHQU1HO0FBQ0gsd0JBQWdCLGVBQWUsQ0FDN0IsT0FBTyxFQUFFLE1BQU0sRUFBRSxHQUFHLENBQUMsTUFBTSxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsRUFDN0MsY0FBYyxFQUFFLE9BQU8sRUFDdkIsS0FBSyxzQkFBZSxFQUNwQixHQUFHLENBQUMsRUFBRSxNQUFNOzs7OztHQThCYiJ9

package/dest/wrappers/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/wrappers/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAOzD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC,EAC7C,cAAc,EAAE,OAAO,EACvB,KAAK,sBAAe,EACpB,GAAG,CAAC,EAAE,MAAM;;;;;GA8Bb"}

package/dest/wrappers/fetch.js

@@ -0,0 +1,42 @@
+import { defaultFetch } from '@aztec-labs/foundation/json-rpc/client';
+import { makeBackoff, retry } from '@aztec-labs/foundation/retry';
+import { SpanKind, SpanStatusCode, context, propagation } from '@opentelemetry/api';
+import { getTelemetryClient } from '../start.js';
+import { ATTR_JSONRPC_METHOD, ATTR_JSONRPC_REQUEST_ID } from '../vendor/attributes.js';
+/**
+ * Makes a fetch function that retries based on the given attempts and propagates trace information.
+ * @param retries - Sequence of intervals (in seconds) to retry, or a factory function returning an iterator for custom/indefinite backoff.
+ * @param noRetry - Whether to stop retries on server errors.
+ * @param log - Optional logger for logging attempts.
+ * @returns A fetch function.
+ */ export function makeTracedFetch(retries, defaultNoRetry, fetch = defaultFetch, log) {
+    return (host, body, extraHeaders = {}, noRetry)=>{
+        const telemetry = getTelemetryClient();
+        return telemetry.getTracer('fetch').startActiveSpan(`JsonRpcClient`, {
+            kind: SpanKind.CLIENT
+        }, async (span)=>{
+            try {
+                if (body && typeof body === 'object' && 'id' in body && typeof body.id === 'number') {
+                    span.setAttribute(ATTR_JSONRPC_REQUEST_ID, body.id);
+                }
+                if (body && typeof body === 'object' && 'method' in body && typeof body.method === 'string') {
+                    span.setAttribute(ATTR_JSONRPC_METHOD, body.method);
+                }
+                const headers = {
+                    ...extraHeaders
+                };
+                propagation.inject(context.active(), headers);
+                const backoff = typeof retries === 'function' ? retries() : makeBackoff(retries);
+                return await retry(()=>fetch(host, body, headers, noRetry ?? defaultNoRetry), `JsonRpcClient request to ${host}`, backoff, log, false);
+            } catch (err) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: err?.message ?? String(err)
+                });
+                throw err;
+            } finally{
+                span.end();
+            }
+        });
+    };
+}

package/dest/wrappers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetch.js';
+export * from './json_rpc_server.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93cmFwcGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHNCQUFzQixDQUFDIn0=

package/dest/wrappers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wrappers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC"}

package/dest/wrappers/index.js

@@ -0,0 +1,2 @@
+export * from './fetch.js';
+export * from './json_rpc_server.js';

package/dest/wrappers/json_rpc_server.d.ts

@@ -0,0 +1,4 @@
+import { type SafeJsonRpcServerOptions } from '@aztec-labs/foundation/json-rpc/server';
+import type { ApiSchemaFor } from '@aztec-labs/stdlib/schemas';
+export declare function createTracedJsonRpcServer<T extends object = any>(handler: T, schema: ApiSchemaFor<T>, options?: SafeJsonRpcServerOptions): import("@aztec-labs/foundation/json-rpc/server").SafeJsonRpcServer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbl9ycGNfc2VydmVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd3JhcHBlcnMvanNvbl9ycGNfc2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLHdCQUF3QixFQUEyQixNQUFNLHdDQUF3QyxDQUFDO0FBQ2hILE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBSy9ELHdCQUFnQix5QkFBeUIsQ0FBQyxDQUFDLFNBQVMsTUFBTSxHQUFHLEdBQUcsRUFDOUQsT0FBTyxFQUFFLENBQUMsRUFDVixNQUFNLEVBQUUsWUFBWSxDQUFDLENBQUMsQ0FBQyxFQUN2QixPQUFPLEdBQUUsd0JBQTZCLHNFQWdCdkMifQ==

package/dest/wrappers/json_rpc_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_rpc_server.d.ts","sourceRoot":"","sources":["../../src/wrappers/json_rpc_server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,wBAAwB,EAA2B,MAAM,wCAAwC,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAK/D,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAC9D,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,OAAO,GAAE,wBAA6B,sEAgBvC"}

package/dest/wrappers/json_rpc_server.js

@@ -0,0 +1,16 @@
+import { createSafeJsonRpcServer } from '@aztec-labs/foundation/json-rpc/server';
+import { getOtelJsonRpcServerMetricsMiddleware } from '../json_rpc_server_metrics.js';
+import { getOtelJsonRpcDiagnosticsMiddleware, getOtelJsonRpcPropagationMiddleware } from '../otel_propagation.js';
+export function createTracedJsonRpcServer(handler, schema, options = {}) {
+    const otelDiagnostics = getOtelJsonRpcDiagnosticsMiddleware();
+    const diagnostic = options.diagnostic ? (ctx, next)=>options.diagnostic(ctx, ()=>otelDiagnostics(ctx, next)) : otelDiagnostics;
+    return createSafeJsonRpcServer(handler, schema, {
+        ...options,
+        diagnostic,
+        middlewares: [
+            getOtelJsonRpcServerMetricsMiddleware(),
+            ...options.middlewares ?? [],
+            getOtelJsonRpcPropagationMiddleware()
+        ]
+    });
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@aztec-labs/telemetry-client",
+  "version": "6.0.0-nightly.20260829",
+  "inherits": [
+    "../package.common.json"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./bench": "./dest/bench.js",
+    "./config": "./dest/config.js",
+    "./start": "./dest/start.js",
+    "./otel-pino-stream": "./dest/vendor/otel-pino-stream.js"
+  },
+  "scripts": {
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "engines": {
+    "node": ">=20.10"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "dependencies": {
+    "@aztec-labs/foundation": "6.0.0-nightly.20260829",
+    "@aztec-labs/stdlib": "6.0.0-nightly.20260829",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.55.0",
+    "@opentelemetry/core": "^1.28.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.55.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.55.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.55.0",
+    "@opentelemetry/host-metrics": "^0.36.2",
+    "@opentelemetry/otlp-exporter-base": "^0.55.0",
+    "@opentelemetry/resource-detector-gcp": "^0.32.0",
+    "@opentelemetry/resources": "^1.28.0",
+    "@opentelemetry/sdk-logs": "^0.55.0",
+    "@opentelemetry/sdk-metrics": "^1.28.0",
+    "@opentelemetry/sdk-trace-node": "^1.28.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
+    "prom-client": "^15.1.3",
+    "viem": "npm:@aztec/viem@2.38.2"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/koa": "^2.15.0",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
+    "jest": "^30.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  },
+  "jest": {
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "reporters": [
+      "default"
+    ],
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "testTimeout": 120000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "testEnvironment": "../../foundation/src/jest/env.mjs",
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setupAfterEnv.mjs"
+    ]
+  }
+}

package/src/attributes.ts

@@ -0,0 +1,174 @@
+/**
+ * @overview This file contains the custom attributes used in telemetry events.
+ * Attribute names exist in a global namespace, alongside metric names. Use this file to ensure that attribute names are unique.
+ *
+ * To define a new attribute follow these steps:
+ * 1. Make sure it's not a semantic attribute that's already been defined by {@link @opentelemetry/semantic-conventions | OpenTelemetry} (e.g. `service.name`)
+ * 2. Come up with a unique name for it so that it doesn't clash with other attributes or metrics.
+ * 3. Prefix the attribute name with `aztec` to make it clear that it's a custom attribute.
+ * 4. Add a description of what the attribute represents and examples of what it might contain.
+ * 5. Start using it.
+ *
+ * @note Attributes and metric names exist in a hierarchy of namespaces. If a name has been used as a namespace, then it can not be used as a name for an attribute or metric.
+ * @example If `aztec.circuit.name` has been defined as an attribute then `aztec.circuit` alone can not be re-used for a metric or attribute because it is already a namespace.
+ * @see {@link https://opentelemetry.io/docs/specs/semconv/general/attribute-naming/}
+ */
+
+/** The host of an HTTP request */
+export const HTTP_REQUEST_HOST = 'http.header.request.host';
+export const HTTP_RESPONSE_STATUS_CODE = 'http.response.status_code';
+
+export const JSON_RPC_REJECTION_REASON = 'aztec.json_rpc.rejection_reason';
+
+/** The Aztec network identifier */
+export const NETWORK_NAME = 'aztec.network_name';
+
+export const AZTEC_NODE_ROLE = 'aztec.node_role';
+export const AZTEC_ROLLUP_VERSION = 'aztec.rollup_version';
+export const AZTEC_ROLLUP_ADDRESS = 'aztec.rollup_address';
+export const AZTEC_REGISTRY_ADDRESS = 'aztec.registry_address';
+
+/**
+ * The name of the protocol circuit being run (e.g. public-kernel-setup or base-rollup)
+ * @see {@link @aztec-labs/stdlib/stats:CircuitName}
+ */
+export const PROTOCOL_CIRCUIT_NAME = 'aztec.circuit.protocol_circuit_name';
+
+/**
+ * For an app circuit, the contract:function being run (e.g. Token:transfer)
+ */
+export const APP_CIRCUIT_NAME = 'aztec.circuit.app_circuit_name';
+
+/** The block archive */
+export const BLOCK_ARCHIVE = 'aztec.block.archive';
+/** The block number */
+export const BLOCK_NUMBER = 'aztec.block.number';
+/** The L2 block hash */
+export const BLOCK_HASH = 'aztec.block.hash';
+/** The slot number */
+export const SLOT_NUMBER = 'aztec.slot.number';
+/** Whether an event happened before or after a slot boundary. */
+export const SLOT_BOUNDARY_SIDE = 'aztec.slot_boundary_side';
+/** The checkpoint number */
+export const CHECKPOINT_NUMBER = 'aztec.checkpoint.number';
+/** The parent's block number */
+export const BLOCK_PARENT = 'aztec.block.parent';
+/** How many txs are being processed to build this block */
+export const BLOCK_CANDIDATE_TXS_COUNT = 'aztec.block.candidate_txs_count';
+/** How many actual txs were included in this block */
+export const BLOCK_TXS_COUNT = 'aztec.block.txs_count';
+/** The block size */
+export const BLOCK_SIZE = 'aztec.block.size';
+/** How many blocks are included in this epoch */
+export const EPOCH_SIZE = 'aztec.epoch.size';
+/** The proposer of a block */
+export const BLOCK_PROPOSER = 'aztec.block.proposer';
+/** The epoch number */
+export const EPOCH_NUMBER = 'aztec.epoch.number';
+/** Kind of an EpochSession: 'full' or 'partial'. */
+export const EPOCH_SESSION_KIND = 'aztec.epoch_session.kind';
+/** The tx hash */
+export const TX_HASH = 'aztec.tx.hash';
+/** Generic attribute representing whether the action was successful or not */
+export const OK = 'aztec.ok';
+/** Generic status attribute */
+export const STATUS = 'aztec.status';
+/** Generic error type attribute */
+export const ERROR_TYPE = 'aztec.error_type';
+/** The cause of an archiver prune (unproven / uncheckpointed / l1_conflict / orphan / l1_mismatch) */
+export const PRUNE_TYPE = 'aztec.archiver.prune_type';
+/** The type of the transaction */
+export const L1_TX_TYPE = 'aztec.l1.tx_type';
+/** The L1 address of the entity that sent a transaction to L1 */
+export const L1_SENDER = 'aztec.l1.sender';
+/** The L1 address receiving rewards */
+export const COINBASE = 'aztec.coinbase';
+/** The phase of the transaction */
+export const TX_PHASE_NAME = 'aztec.tx.phase_name';
+/** The reason for disconnecting a peer */
+export const P2P_GOODBYE_REASON = 'aztec.p2p.goodbye.reason';
+/** The proving job type */
+export const PROVING_JOB_TYPE = 'aztec.proving.job_type';
+/** The proving job id */
+export const PROVING_JOB_ID = 'aztec.proving.job_id';
+/** Merkle tree name */
+export const MERKLE_TREE_NAME = 'aztec.merkle_tree.name';
+/** The prover-id in a root rollup proof. */
+export const ROLLUP_PROVER_ID = 'aztec.rollup.prover_id';
+/** Whether the proof submission was timed out (delayed more than 20 min) */
+export const PROOF_TIMED_OUT = 'aztec.proof.timed_out';
+/** Status of the validator (eg proposer, in-committee, none) */
+export const VALIDATOR_STATUS = 'aztec.validator_status';
+
+export const P2P_ID = 'aztec.p2p.id';
+export const P2P_REQ_RESP_PROTOCOL = 'aztec.p2p.req_resp.protocol';
+/** The state of a peer (Healthy, Disconnect, Banned) */
+export const P2P_PEER_SCORE_STATE = 'aztec.p2p.peer_score_state';
+export const POOL_NAME = 'aztec.pool.name';
+
+export const PEER_ID = 'aztec.p2p.peer_id';
+
+export const SEQUENCER_STATE = 'aztec.sequencer.state';
+
+export const SIMULATOR_PHASE = 'aztec.simulator.phase';
+export const TARGET_ADDRESS = 'aztec.address.target';
+export const SENDER_ADDRESS = 'aztec.address.sender';
+export const MANA_USED = 'aztec.mana.used';
+export const TOTAL_INSTRUCTIONS = 'aztec.total_instructions';
+
+/** Whether a sync process is the initial run, which is usually slower than iterative ones. */
+export const INITIAL_SYNC = 'aztec.initial_sync';
+
+/** Identifier for the tables in a world state DB */
+export const WS_DB_DATA_TYPE = 'aztec.world_state.db_type';
+
+/** Identifier for component database (e.g. archiver, tx pool) */
+export const DB_DATA_TYPE = 'aztec.db_type';
+
+export const REVERTIBILITY = 'aztec.revertibility';
+
+export const GAS_DIMENSION = 'aztec.gas_dimension';
+
+export const WORLD_STATE_REQUEST_TYPE = 'aztec.world_state_request';
+
+export const NODEJS_EVENT_LOOP_STATE = 'nodejs.eventloop.state';
+
+export const TOPIC_NAME = 'aztec.gossip.topic_name';
+
+/** Stage of gossiped tx validation (deserialize, fast_validation_setup, fast_validation, pool_precheck, proof_verify, pool_add) */
+export const TX_VALIDATION_STAGE = 'aztec.p2p.tx_validation_stage';
+
+/** Operation type enqueued on the mempool serial queue */
+export const MEMPOOL_OPERATION = 'aztec.mempool.operation';
+
+/** The reason a transaction was evicted from the tx pool */
+export const TX_POOL_EVICTION_REASON = 'aztec.mempool.eviction_reason';
+
+export const TX_COLLECTION_METHOD = 'aztec.tx_collection.method';
+
+/** Scope of L1 transaction (sequencer, prover, or other) */
+export const L1_TX_SCOPE = 'aztec.l1_tx.scope';
+
+/** Generic error type attribute */
+export const IS_COMMITTEE_MEMBER = 'aztec.is_committee_member';
+
+/** Fisherman fee analysis strategy identifier */
+export const FISHERMAN_FEE_STRATEGY_ID = 'aztec.fisherman.strategy_id';
+
+/** Whether the analyzed block reached 100% blob capacity */
+export const BLOCK_FULL = 'aztec.block_full';
+
+/** The L1 transaction target for block proposal */
+export const L1_BLOCK_PROPOSAL_TX_TARGET = 'aztec.l1.block_proposal_tx_target';
+
+/** Whether tracing methods were used to extract block proposal data */
+export const L1_BLOCK_PROPOSAL_USED_TRACE = 'aztec.l1.block_proposal_used_trace';
+
+/** HA signer duty type (e.g., BLOCK_PROPOSAL, CHECKPOINT_ATTESTATION) */
+export const HA_DUTY_TYPE = 'aztec.ha_signer.duty_type';
+
+/** HA signer node identifier */
+export const HA_NODE_ID = 'aztec.ha_signer.node_id';
+
+/** The address of an attester (validator) participating in consensus */
+export const ATTESTER_ADDRESS = 'aztec.attester.address';

package/src/bench.ts

@@ -0,0 +1,168 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import type { BatchObservableCallback, Context, MetricOptions, Observable, ValueType } from '@opentelemetry/api';
+
+import type { MetricDefinition } from './metrics.js';
+import { NoopTracer } from './noop.js';
+import type {
+  AttributesType,
+  Gauge,
+  Histogram,
+  Meter,
+  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[] = [];
+
+  constructor() {
+    const log = createLogger('telemetry:client');
+    log.info(`Using benchmark telemetry client`);
+  }
+
+  setExportedPublicTelemetry(_prefixes: string[]): void {}
+  setPublicTelemetryCollectFrom(_roles: string[]): void {}
+
+  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;
+  }
+
+  getTraceContext(): string | undefined {
+    return undefined;
+  }
+
+  extractPropagatedContext() {
+    return undefined;
+  }
+
+  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(metric: MetricDefinition): Gauge {
+    return this.createMetric('gauge', metric);
+  }
+
+  createObservableGauge(metric: MetricDefinition): ObservableGauge {
+    return this.createMetric('gauge', metric);
+  }
+
+  createHistogram(metric: MetricDefinition, _extraOptions?: Partial<MetricOptions>): Histogram {
+    return this.createMetric('histogram', metric);
+  }
+
+  createUpDownCounter(metric: MetricDefinition): UpDownCounter {
+    return this.createMetric('counter', metric);
+  }
+
+  createObservableUpDownCounter(metric: MetricDefinition): ObservableUpDownCounter {
+    return this.createMetric('counter', metric);
+  }
+
+  private createMetric(type: 'gauge' | 'counter' | 'histogram', metric: MetricDefinition) {
+    const m = new InMemoryPlainMetric(type, metric.name, {
+      description: metric.description,
+      unit: metric.unit,
+      valueType: metric.valueType,
+    });
+    this.metrics.push(m);
+    return m;
+  }
+
+  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);
+  }
+}