@aztec/telemetry-client 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/telemetry-client",
-  "version": "0.0.1-commit.f2ce05ee",
+  "version": "0.0.1-commit.f5a9928",
   "inherits": [
     "../package.common.json"
   ],
@@ -27,8 +27,8 @@
     "!*.test.*"
   ],
   "dependencies": {
-    "@aztec/foundation": "0.0.1-commit.f2ce05ee",
-    "@aztec/stdlib": "0.0.1-commit.f2ce05ee",
+    "@aztec/foundation": "0.0.1-commit.f5a9928",
+    "@aztec/stdlib": "0.0.1-commit.f5a9928",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "^0.55.0",
     "@opentelemetry/core": "^1.28.0",

package/src/attributes.ts

@@ -18,6 +18,8 @@
 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';
 
@@ -45,6 +47,8 @@ export const BLOCK_NUMBER = 'aztec.block.number';
 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 */
@@ -61,6 +65,8 @@ export const EPOCH_SIZE = 'aztec.epoch.size';
 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 */
@@ -69,6 +75,8 @@ export const OK = 'aztec.ok';
 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 */
@@ -94,7 +102,6 @@ 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';
-export const P2P_REQ_RESP_BATCH_REQUESTS_COUNT = 'aztec.p2p.req_resp.batch_requests_count';
 /** 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';
@@ -128,6 +135,15 @@ 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) */
@@ -139,8 +155,20 @@ 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/config.ts

@@ -1,4 +1,9 @@
-import { type ConfigMappingsType, booleanConfigHelper, getConfigFromMappings } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 
 export interface TelemetryClientConfig {
   metricsCollectorUrl?: URL;
@@ -12,35 +17,35 @@ export interface TelemetryClientConfig {
   otelExportTimeoutMs: number;
   otelExcludeMetrics: string[];
   otelIncludeMetrics: string[];
+  otelMinTraceDurationMs: number;
+  otelBspMaxQueueSize: number;
 }
 
 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),
+    parseEnv: (val: string) => 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),
+    parseEnv: (val: string) => 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),
+    parseEnv: (val: string) => 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),
+    ...numberConfigHelper(60000),
   },
   otelExportTimeoutMs: {
     env: 'OTEL_EXPORT_TIMEOUT_MS',
     description: 'The timeout for exporting metrics',
-    defaultValue: 30000, // Default extracted from otel client
-    parseEnv: (val: string) => parseInt(val),
+    ...numberConfigHelper(30000),
   },
   otelExcludeMetrics: {
     env: 'OTEL_EXCLUDE_METRICS',
@@ -54,6 +59,16 @@ export const telemetryClientConfigMappings: ConfigMappingsType<TelemetryClientCo
         : [],
     defaultValue: [],
   },
+  otelMinTraceDurationMs: {
+    env: 'OTEL_MIN_TRACE_DURATION_MS',
+    description: 'The minimum successful trace duration to export in milliseconds. Set to 0 to export all traces.',
+    ...numberConfigHelper(10),
+  },
+  otelBspMaxQueueSize: {
+    env: 'OTEL_BSP_MAX_QUEUE_SIZE',
+    description: 'The maximum number of completed spans to queue before export.',
+    ...numberConfigHelper(16384),
+  },
   otelIncludeMetrics: {
     env: 'OTEL_INCLUDE_METRICS',
     description: 'A list of metric prefixes to include in export (ignored if OTEL_EXCLUDE_METRICS is set)',
@@ -70,7 +85,7 @@ export const telemetryClientConfigMappings: ConfigMappingsType<TelemetryClientCo
   publicMetricsCollectorUrl: {
     env: 'PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT',
     description: 'A URL to publish a subset of metrics for public consumption',
-    parseEnv: (val: string) => val && new URL(val),
+    parseEnv: (val: string) => new URL(val),
   },
   publicMetricsCollectFrom: {
     env: 'PUBLIC_OTEL_COLLECT_FROM',

package/src/index.ts

@@ -8,3 +8,4 @@ export * from './l1_metrics.js';
 export * from './wrappers/index.js';
 export * from './start.js';
 export * from './otel_propagation.js';
+export * from './json_rpc_server_metrics.js';

package/src/json_rpc_server_metrics.ts

@@ -0,0 +1,151 @@
+import { Timer } from '@aztec/foundation/timer';
+
+import type Koa from 'koa';
+
+import * as Attributes from './attributes.js';
+import * as Metrics from './metrics.js';
+import { getTelemetryClient } from './start.js';
+import type { Histogram, MetricAttributesType, TelemetryClient, UpDownCounter } from './telemetry.js';
+import { ATTR_JSONRPC_METHOD, ATTR_JSONRPC_SERVICE } from './vendor/attributes.js';
+
+const BATCH_SIZE_BUCKETS = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000];
+
+/** Fixed reasons for rejecting an RPC request before dispatching it to a registered handler. */
+export type JsonRpcRejectionReason =
+  | 'unauthorized'
+  | 'parse_error'
+  | 'invalid_request'
+  | 'method_not_found'
+  | 'bad_request'
+  | 'internal_error';
+
+/** Records bounded-cardinality metrics for registered JSON-RPC calls, rejected requests, and batches. */
+export class JsonRpcServerMetrics {
+  private readonly requestCount: UpDownCounter;
+  private readonly requestDuration: Histogram;
+  private readonly requestValidationDuration: Histogram;
+  private readonly rejectedRequestCount: UpDownCounter;
+  private readonly batchCount: UpDownCounter;
+  private readonly batchDuration: Histogram;
+  private readonly batchSize: Histogram;
+
+  constructor(telemetry: TelemetryClient) {
+    const meter = telemetry.getMeter('JsonRpcServer');
+    this.requestCount = meter.createUpDownCounter(Metrics.JSON_RPC_SERVER_REQUEST_COUNT);
+    this.requestDuration = meter.createHistogram(Metrics.JSON_RPC_SERVER_REQUEST_DURATION);
+    this.requestValidationDuration = meter.createHistogram(Metrics.JSON_RPC_SERVER_REQUEST_VALIDATION_DURATION);
+    this.rejectedRequestCount = meter.createUpDownCounter(Metrics.JSON_RPC_SERVER_REJECTED_REQUEST_COUNT);
+    this.batchCount = meter.createUpDownCounter(Metrics.JSON_RPC_SERVER_BATCH_COUNT);
+    this.batchDuration = meter.createHistogram(Metrics.JSON_RPC_SERVER_BATCH_DURATION);
+    this.batchSize = meter.createHistogram(Metrics.JSON_RPC_SERVER_BATCH_SIZE, {
+      advice: { explicitBucketBoundaries: BATCH_SIZE_BUCKETS },
+    });
+  }
+
+  /** Records the outcome and handler duration of a registered RPC method. */
+  public recordRequest(fullMethod: string, durationMs: number, ok: boolean): void {
+    const [service, method] = splitJsonRpcMethod(fullMethod);
+    const attributes: MetricAttributesType = {
+      ...(service === undefined ? {} : { [ATTR_JSONRPC_SERVICE]: service }),
+      [ATTR_JSONRPC_METHOD]: method,
+      [Attributes.OK]: ok,
+    };
+    this.requestCount.add(1, attributes);
+    this.requestDuration.record(durationMs, attributes);
+  }
+
+  /** Records a pre-dispatch rejection using a fixed reason. */
+  public recordRejectedRequest(reason: JsonRpcRejectionReason): void {
+    this.rejectedRequestCount.add(1, { [Attributes.JSON_RPC_REJECTION_REASON]: reason });
+  }
+
+  /** Records the duration and outcome of validating a registered RPC method's parameters. */
+  public recordRequestValidation(fullMethod: string, durationMs: number, ok: boolean): void {
+    const [service, method] = splitJsonRpcMethod(fullMethod);
+    this.requestValidationDuration.record(durationMs, {
+      ...(service === undefined ? {} : { [ATTR_JSONRPC_SERVICE]: service }),
+      [ATTR_JSONRPC_METHOD]: method,
+      [Attributes.OK]: ok,
+    });
+  }
+
+  /** Records the outcome, processing duration, and number of calls in a batch envelope. */
+  public recordBatch(size: number, durationMs: number, ok: boolean): void {
+    const attributes = { [Attributes.OK]: ok };
+    this.batchCount.add(1, attributes);
+    this.batchDuration.record(durationMs, attributes);
+    this.batchSize.record(size, attributes);
+  }
+}
+
+let metricsOwner: TelemetryClient | undefined;
+let metrics: JsonRpcServerMetrics | undefined;
+
+export function getJsonRpcServerMetrics(): JsonRpcServerMetrics {
+  const telemetry = getTelemetryClient();
+  if (metricsOwner !== telemetry) {
+    metricsOwner = telemetry;
+    metrics = new JsonRpcServerMetrics(telemetry);
+  }
+  return metrics!;
+}
+
+export function getOtelJsonRpcServerMetricsMiddleware(
+  metricsProvider: () => Pick<JsonRpcServerMetrics, 'recordBatch' | 'recordRejectedRequest'> = getJsonRpcServerMetrics,
+): (ctx: Koa.Context, next: () => Promise<void>) => Promise<void> {
+  return async function otelJsonRpcServerMetrics(ctx, next) {
+    const timer = new Timer();
+    await next();
+
+    const requestBody = (ctx.request as { body?: unknown }).body;
+    if (Array.isArray(requestBody)) {
+      metricsProvider().recordBatch(requestBody.length, timer.ms(), Array.isArray(ctx.body));
+    }
+
+    for (const reason of getRejectionReasons(ctx.status, ctx.body)) {
+      metricsProvider().recordRejectedRequest(reason);
+    }
+  };
+}
+
+export function splitJsonRpcMethod(fullMethod: string): [service: string | undefined, method: string] {
+  const separator = fullMethod.indexOf('_');
+  return separator === -1 ? [undefined, fullMethod] : [fullMethod.slice(0, separator), fullMethod.slice(separator + 1)];
+}
+
+function getRejectionReasons(status: number, response: unknown): JsonRpcRejectionReason[] {
+  if (status === 401) {
+    return ['unauthorized'];
+  }
+
+  const responses = Array.isArray(response) ? response : [response];
+  return responses.flatMap(item => {
+    const code = getErrorCode(item);
+    if (code === -32700) {
+      return ['parse_error'];
+    }
+    if (code === -32601) {
+      return ['method_not_found'];
+    }
+    if (code === -32600) {
+      return ['invalid_request'];
+    }
+    if (code === -32603) {
+      return ['internal_error'];
+    }
+    if (code === -32000) {
+      return ['bad_request'];
+    }
+    return [];
+  });
+}
+
+function getErrorCode(response: unknown): number | undefined {
+  if (!response || typeof response !== 'object' || !('error' in response)) {
+    return undefined;
+  }
+  const error = response.error;
+  return error && typeof error === 'object' && 'code' in error && typeof error.code === 'number'
+    ? error.code
+    : undefined;
+}