@aztec/telemetry-client 0.0.0-test.0

package/dest/vendor/otel-pino-stream.js

@@ -0,0 +1,229 @@
+/*
+ * Adapted from open-telemetry/opentelemetry-js-contrib
+ * All changes are prefixed with [aztec] to make them easy to identify
+ *
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { SeverityNumber, logs } from '@opentelemetry/api-logs';
+import { millisToHrTime } from '@opentelemetry/core';
+import { Writable } from 'stream';
+import { registerOtelLoggerProvider } from '../otel_logger_provider.js';
+import { getOtelResource } from '../otel_resource.js';
+/* eslint-disable @typescript-eslint/ban-types */ /* eslint-disable camelcase */ // This block is a copy (modulo code style and TypeScript types) of the Pino
+// code that defines log level value and names. This file is part of
+// *instrumenting* Pino, so we want to avoid a dependency on the library.
+const DEFAULT_LEVELS = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60
+};
+const OTEL_SEV_NUM_FROM_PINO_LEVEL = {
+    [DEFAULT_LEVELS.trace]: SeverityNumber.TRACE,
+    [DEFAULT_LEVELS.debug]: SeverityNumber.DEBUG,
+    [DEFAULT_LEVELS.info]: SeverityNumber.INFO,
+    [DEFAULT_LEVELS.warn]: SeverityNumber.WARN,
+    [DEFAULT_LEVELS.error]: SeverityNumber.ERROR,
+    [DEFAULT_LEVELS.fatal]: SeverityNumber.FATAL
+};
+const EXTRA_SEV_NUMS = [
+    SeverityNumber.TRACE2,
+    SeverityNumber.TRACE3,
+    SeverityNumber.TRACE4,
+    SeverityNumber.DEBUG2,
+    SeverityNumber.DEBUG3,
+    SeverityNumber.DEBUG4,
+    SeverityNumber.INFO2,
+    SeverityNumber.INFO3,
+    SeverityNumber.INFO4,
+    SeverityNumber.WARN2,
+    SeverityNumber.WARN3,
+    SeverityNumber.WARN4,
+    SeverityNumber.ERROR2,
+    SeverityNumber.ERROR3,
+    SeverityNumber.ERROR4,
+    SeverityNumber.FATAL2,
+    SeverityNumber.FATAL3,
+    SeverityNumber.FATAL4
+];
+function severityNumberFromPinoLevel(lvl) {
+    // Fast common case: one of the known levels
+    const sev = OTEL_SEV_NUM_FROM_PINO_LEVEL[lvl];
+    if (sev !== undefined) {
+        return sev;
+    }
+    // Otherwise, scale the Pino level range -- 10 (trace) to 70 (fatal+10)
+    // -- onto the extra OTel severity numbers (TRACE2, TRACE3, ..., FATAL4).
+    // Values below trace (10) map to SeverityNumber.TRACE2, which may be
+    // considered a bit weird, but it means the unnumbered levels are always
+    // just for exactly matching values.
+    const relativeLevelWeight = (lvl - 10) / (70 - 10);
+    const otelSevIdx = Math.floor(relativeLevelWeight * EXTRA_SEV_NUMS.length);
+    const cappedOTelIdx = Math.min(EXTRA_SEV_NUMS.length - 1, Math.max(0, otelSevIdx));
+    const otelSevValue = EXTRA_SEV_NUMS[cappedOTelIdx];
+    return otelSevValue;
+}
+// [aztec] Custom function to map Aztec logging levels to OpenTelemetry severity numbers
+function severityNumberFromAztecPinoLevel(lvl) {
+    return OTEL_SEV_NUM_FROM_PINO_LEVEL[lvl] ?? /* verbose */ (lvl === 25 ? SeverityNumber.DEBUG3 : undefined) ?? severityNumberFromPinoLevel(lvl);
+}
+/**
+ * Return a function that knows how to convert the "time" field value on a
+ * Pino log record to an OTel LogRecord timestamp value.
+ *
+ * How to convert the serialized "time" on a Pino log record
+ * depends on the Logger's `Symbol(pino.time)` prop, configurable
+ * via https://getpino.io/#/docs/api?id=timestamp-boolean-function
+ *
+ * For example:
+ *    const logger = pino({timestamp: pino.stdTimeFunctions.isoTime})
+ * results in log record entries of the form:
+ *    ,"time":"2024-05-17T22:03:25.969Z"
+ * `otelTimestampFromTime` will be given the value of the "time" field:
+ *   "2024-05-17T22:03:25.969Z"
+ * which should be parsed to a number of milliseconds since the epoch.
+ */ export function getTimeConverter(pinoLogger, pinoMod) {
+    const stdTimeFns = pinoMod.stdTimeFunctions;
+    const loggerTimeFn = pinoLogger[pinoMod.symbols.timeSym];
+    if (loggerTimeFn === stdTimeFns.epochTime) {
+        return (time)=>time;
+    } else if (loggerTimeFn === stdTimeFns.unixTime) {
+        return (time)=>time * 1e3;
+    } else if (loggerTimeFn === stdTimeFns.isoTime) {
+        return (time)=>new Date(time).getTime();
+    } else if (loggerTimeFn === stdTimeFns.nullTime) {
+        return ()=>Date.now();
+    } else {
+        // The logger has a custom time function. Don't guess.
+        return ()=>NaN;
+    }
+}
+/**
+ * A Pino stream for sending records to the OpenTelemetry Logs API.
+ *
+ * - This stream emits an 'unknown' event on an unprocessable pino record.
+ *   The event arguments are: `logLine: string`, `err: string | Error`.
+ */ export class OTelPinoStream extends Writable {
+    _otelLogger;
+    _messageKey;
+    _levels;
+    _otelTimestampFromTime;
+    constructor(options){
+        super();
+        // Note: A PINO_CONFIG event was added to pino (2024-04-04) to send config
+        // to transports. Eventually OTelPinoStream might be able to use this
+        // for auto-configuration in newer pino versions. The event currently does
+        // not include the `timeSym` value that is needed here, however.
+        this._messageKey = options.messageKey ?? 'msg';
+        this._levels = options.levels;
+        // [aztec] The following will break if we set up a custom time function in our logger
+        this._otelTimestampFromTime = options.otelTimestampFromTime ?? ((time)=>time);
+        // Cannot use `instrumentation.logger` until have delegating LoggerProvider:
+        // https://github.com/open-telemetry/opentelemetry-js/issues/4399
+        // [aztec] Use the name of this package
+        this._otelLogger = logs.getLogger('@aztec/telemetry-client/otel-pino-stream', '0.1.0');
+    }
+    _write(s, _encoding, callback) {
+        try {
+            /* istanbul ignore if */ if (!s) {
+                return;
+            }
+            // Parse, and handle edge cases similar to how `pino-abtract-transport` does:
+            // https://github.com/pinojs/pino-abstract-transport/blob/v1.2.0/index.js#L28-L45
+            // - Emitting an 'unknown' event on parse error mimicks pino-abstract-transport.
+            let recObj;
+            try {
+                recObj = JSON.parse(s);
+            } catch (parseErr) {
+                // Invalid JSON suggests a bug in Pino, or a logger configuration bug
+                // (a bogus `options.timestamp` or serializer).
+                this.emit('unknown', s.toString(), parseErr);
+                callback();
+                return;
+            }
+            /* istanbul ignore if */ if (recObj === null) {
+                this.emit('unknown', s.toString(), 'Null value ignored');
+                callback();
+                return;
+            }
+            /* istanbul ignore if */ if (typeof recObj !== 'object') {
+                recObj = {
+                    data: recObj
+                };
+            }
+            const { time, [this._messageKey]: body, level, // The typical Pino `hostname` and `pid` fields are removed because they
+            // are redundant with the OpenTelemetry `host.name` and `process.pid`
+            // Resource attributes, respectively. This code cannot change the
+            // LoggerProvider's `resource`, so getting the OpenTelemetry equivalents
+            // depends on the user using the OpenTelemetry HostDetector and
+            // ProcessDetector.
+            // https://getpino.io/#/docs/api?id=opt-base
+            hostname, pid, // The `trace_id` et al fields that may have been added by the
+            // "log correlation" feature are stripped, because they are redundant.
+            // trace_id, // eslint-disable-line @typescript-eslint/no-unused-vars
+            // span_id, // eslint-disable-line @typescript-eslint/no-unused-vars
+            // trace_flags, // eslint-disable-line @typescript-eslint/no-unused-vars
+            // [aztec] They are not redundant, we depend on them for correlation.
+            // The instrumentation package seems to be adding these fields via a custom hook.
+            // We push them from the logger module in foundation, so we don't want to clear them here.
+            ...attributes } = recObj;
+            let timestamp = this._otelTimestampFromTime(time);
+            if (isNaN(timestamp)) {
+                attributes['time'] = time; // save the unexpected "time" field to attributes
+                timestamp = Date.now();
+            }
+            // This avoids a possible subtle bug when a Pino logger uses
+            // `time: pino.stdTimeFunctions.unixTime` and logs in the first half-second
+            // since process start. The rounding involved results in:
+            //    timestamp < performance.timeOrigin
+            // If that is passed to Logger.emit() it will be misinterpreted by
+            // `timeInputToHrTime` as a `performance.now()` value.
+            const timestampHrTime = millisToHrTime(timestamp);
+            // Prefer using `stream.lastLevel`, because `recObj.level` can be customized
+            // to anything via `formatters.level`
+            // (https://getpino.io/#/docs/api?id=formatters-object).
+            // const lastLevel = (this as any).lastLevel;
+            // [aztec] We do not prefer stream.lastLevel since it's undefined here, as we are running
+            // on a worker thread, so we use recObj.level because we know that we won't customize it.
+            const lastLevel = recObj.level;
+            const otelRec = {
+                timestamp: timestampHrTime,
+                observedTimestamp: timestampHrTime,
+                severityNumber: severityNumberFromAztecPinoLevel(lastLevel),
+                severityText: this._levels.labels[lastLevel],
+                body,
+                attributes
+            };
+            this._otelLogger.emit(otelRec);
+        } catch (err) {
+            // [aztec] Log errors to stderr
+            // eslint-disable-next-line no-console
+            console.error(`Error in OTelPinoStream: ${err}`);
+        }
+        callback();
+    }
+}
+// [aztec] Default export that loads the resource information and creates a new otel pino stream.
+// Invoked by pino when creating a transport in a worker thread out of this stream.
+// Note that the original open-telemetry/opentelemetry-js-contrib was set up to run on the main
+// nodejs loop, as opposed to in a worker as pino recommends.
+export default function(options) {
+    const url = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
+    const resource = getOtelResource();
+    // We re-register here because this runs on a worker thread
+    registerOtelLoggerProvider(resource, url ? new URL(url) : undefined);
+    return new OTelPinoStream(options);
+}

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/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=with_tracer.d.ts.map

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;gBACnB,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM;CAGlD"}

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/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/foundation/json-rpc/client';
+import type { Logger } from '@aztec/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.
+ * @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[], defaultNoRetry: boolean, fetch?: typeof defaultFetch, log?: Logger): (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, extraHeaders?: Record<string, string>, noRetry?: boolean) => Promise<{
+    response: any;
+    headers: {
+        get: (header: string) => string | null | undefined;
+    };
+}>;
+//# sourceMappingURL=fetch.d.ts.map

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,mCAAmC,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAQpD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,sBAAe,EAAE,GAAG,CAAC,EAAE,MAAM,UAEpG,MAAM,aACD,MAAM,QACX,GAAG,mBACQ,OAAO,iBACV,OAAO,MAAM,EAAE,MAAM,CAAC,YAC1B,OAAO;;;;;GA4BpB"}

package/dest/wrappers/fetch.js

@@ -0,0 +1,39 @@
+import { defaultFetch } from '@aztec/foundation/json-rpc/client';
+import { makeBackoff, retry } from '@aztec/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.
+ * @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, rpcMethod, body, useApiEndpoints, extraHeaders = {}, noRetry)=>{
+        const telemetry = getTelemetryClient();
+        return telemetry.getTracer('fetch').startActiveSpan(`JsonRpcClient.${rpcMethod}`, {
+            kind: SpanKind.CLIENT
+        }, async (span)=>{
+            try {
+                if (body && typeof body.id === 'number') {
+                    span.setAttribute(ATTR_JSONRPC_REQUEST_ID, body.id);
+                }
+                span.setAttribute(ATTR_JSONRPC_METHOD, rpcMethod);
+                const headers = {
+                    ...extraHeaders
+                };
+                propagation.inject(context.active(), headers);
+                return await retry(()=>fetch(host, rpcMethod, body, useApiEndpoints, headers, noRetry ?? defaultNoRetry), `JsonRpcClient request ${rpcMethod} to ${host}`, makeBackoff(retries), 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,4 @@
+export * from './l2_block_stream.js';
+export * from './fetch.js';
+export * from './json_rpc_server.js';
+//# sourceMappingURL=index.d.ts.map

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,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC"}

package/dest/wrappers/index.js

@@ -0,0 +1,3 @@
+export * from './l2_block_stream.js';
+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/foundation/json-rpc/server';
+import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
+export declare function createTracedJsonRpcServer<T extends object = any>(handler: T, schema: ApiSchemaFor<T>, options?: Partial<SafeJsonRpcServerOptions>): import("@aztec/foundation/json-rpc/server").SafeJsonRpcServer;
+//# sourceMappingURL=json_rpc_server.d.ts.map

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,mCAAmC,CAAC;AAC3G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAI1D,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAC9D,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,OAAO,GAAE,OAAO,CAAC,wBAAwB,CAAM,iEAMhD"}

package/dest/wrappers/json_rpc_server.js

@@ -0,0 +1,11 @@
+import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { getOtelJsonRpcPropagationMiddleware } from '../otel_propagation.js';
+export function createTracedJsonRpcServer(handler, schema, options = {}) {
+    return createSafeJsonRpcServer(handler, schema, {
+        ...options,
+        middlewares: [
+            ...options.middlewares ?? [],
+            getOtelJsonRpcPropagationMiddleware()
+        ]
+    });
+}

package/dest/wrappers/l2_block_stream.d.ts

@@ -0,0 +1,15 @@
+import { type L2BlockSource, L2BlockStream, type L2BlockStreamEventHandler, type L2BlockStreamLocalDataProvider } from '@aztec/stdlib/block';
+import { type Traceable, type Tracer } from '@aztec/telemetry-client';
+/** Extends an L2BlockStream with a tracer to create a new trace per iteration. */
+export declare class TraceableL2BlockStream extends L2BlockStream implements Traceable {
+    readonly tracer: Tracer;
+    private readonly name;
+    constructor(l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'>, localData: L2BlockStreamLocalDataProvider, handler: L2BlockStreamEventHandler, tracer: Tracer, name?: string, log?: import("@aztec/foundation/log").Logger, opts?: {
+        proven?: boolean;
+        pollIntervalMS?: number;
+        batchSize?: number;
+        startingBlock?: number;
+    });
+    work(): Promise<void>;
+}
+//# sourceMappingURL=l2_block_stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"l2_block_stream.d.ts","sourceRoot":"","sources":["../../src/wrappers/l2_block_stream.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,aAAa,EAClB,aAAa,EACb,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EACpC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM,EAAa,MAAM,yBAAyB,CAAC;AAEjF,kFAAkF;AAClF,qBAAa,sBAAuB,SAAQ,aAAc,YAAW,SAAS;aAK1D,MAAM,EAAE,MAAM;IAC9B,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAJrB,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,WAAW,GAAG,gBAAgB,GAAG,WAAW,CAAC,EAChF,SAAS,EAAE,8BAA8B,EACzC,OAAO,EAAE,yBAAyB,EAClB,MAAM,EAAE,MAAM,EACb,IAAI,GAAE,MAAwB,EAC/C,GAAG,yCAAqC,EACxC,IAAI,GAAE;QACJ,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;KACnB;IAUC,IAAI;CAGd"}

package/dest/wrappers/l2_block_stream.js

@@ -0,0 +1,26 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createLogger } from '@aztec/foundation/log';
+import { L2BlockStream } from '@aztec/stdlib/block';
+import { trackSpan } from '@aztec/telemetry-client';
+/** Extends an L2BlockStream with a tracer to create a new trace per iteration. */ export class TraceableL2BlockStream extends L2BlockStream {
+    tracer;
+    name;
+    constructor(l2BlockSource, localData, handler, tracer, name = 'L2BlockStream', log = createLogger('types:block_stream'), opts = {}){
+        super(l2BlockSource, localData, handler, log, opts), this.tracer = tracer, this.name = name;
+    }
+    // We need to use a non-arrow function to be able to access `this`
+    // See https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function
+    work() {
+        return super.work();
+    }
+}
+_ts_decorate([
+    trackSpan(function() {
+        return `${this.name}.work`;
+    })
+], TraceableL2BlockStream.prototype, "work", null);

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@aztec/telemetry-client",
+  "inherits": [
+    "../package.common.json"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./bench": "./dest/bench.js",
+    "./otel-pino-stream": "./dest/vendor/otel-pino-stream.js"
+  },
+  "scripts": {
+    "build": "yarn clean && tsc -b",
+    "build:dev": "tsc -b --watch",
+    "clean": "rm -rf ./dest .tsbuildinfo",
+    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
+    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "dependencies": {
+    "@aztec/foundation": "0.0.0-test.0",
+    "@aztec/stdlib": "0.0.0-test.0",
+    "@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.35.4",
+    "@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"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/koa": "^2.15.0",
+    "jest": "^29.5.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "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"
+    ]
+  },
+  "version": "0.0.0-test.0"
+}

package/src/attributes.ts

@@ -0,0 +1,115 @@
+/**
+ * @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 Aztec network identifier */
+export const NETWORK_NAME = 'aztec.network_name';
+
+/**
+ * The name of the protocol circuit being run (e.g. public-kernel-setup or base-rollup)
+ * @see {@link @aztec/stdlib/stats:CircuitName}
+ */
+export const PROTOCOL_CIRCUIT_NAME = 'aztec.circuit.protocol_circuit_name';
+
+/**
+ * The type of protocol circuit being run: server or client
+ */
+export const PROTOCOL_CIRCUIT_TYPE = 'aztec.circuit.protocol_circuit_type';
+
+/**
+ * For an app circuit, the contract:function being run (e.g. Token:transfer)
+ */
+export const APP_CIRCUIT_NAME = 'aztec.circuit.app_circuit_name';
+
+/**
+ * The type of app circuit being run: server or client
+ */
+export const APP_CIRCUIT_TYPE = 'aztec.circuit.app_circuit_type';
+
+/** The block archive */
+export const BLOCK_ARCHIVE = 'aztec.block.archive';
+/** The block number */
+export const BLOCK_NUMBER = 'aztec.block.number';
+/** The slot number */
+export const SLOT_NUMBER = 'aztec.slot.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';
+/** 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 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 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';
+
+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';
+
+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';
+export const POOL_NAME = 'aztec.pool.name';
+
+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';
+
+/** 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';