@aztec/telemetry-client 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/telemetry.ts

@@ -1,6 +1,7 @@
 import {
   type AttributeValue,
   type BatchObservableCallback,
+  type Context,
   type MetricOptions,
   type Observable,
   type BatchObservableResult as OtelBatchObservableResult,
@@ -14,31 +15,62 @@ import {
   SpanStatusCode,
   type Tracer,
 } from '@opentelemetry/api';
-import { isPromise } from 'node:util/types';
 
 import type * as Attributes from './attributes.js';
-import type * as Metrics from './metrics.js';
+import type { MetricDefinition } from './metrics.js';
 import { getTelemetryClient } from './start.js';
 
-export { type Span, SpanStatusCode, ValueType } from '@opentelemetry/api';
+export { toMetricOptions, createUpDownCounterWithDefault } from './metric-utils.js';
+
+export { type Span, SpanStatusCode, ValueType, type Context } from '@opentelemetry/api';
 
 type ValuesOf<T> = T extends Record<string, infer U> ? U : never;
 
+type AttributeNames = ValuesOf<typeof Attributes>;
+
+/**
+ * This is a set of attributes that could lead to high cardinality in the metrics.
+ * If you find yourself wanting to capture this data in a metric consider if it makes sense to capture
+ * as the metric value instead of an attribute or consider logging instead.
+ *
+ * Think twice before removing an attribute from this list.
+ */
+type BannedMetricAttributeNames = (typeof Attributes)[
+  | 'BLOCK_NUMBER'
+  | 'BLOCK_ARCHIVE'
+  | 'SLOT_NUMBER'
+  | 'BLOCK_PARENT'
+  | 'BLOCK_CANDIDATE_TXS_COUNT'
+  | 'BLOCK_TXS_COUNT'
+  | 'BLOCK_SIZE'
+  | 'EPOCH_SIZE'
+  | 'EPOCH_NUMBER'
+  | 'TX_HASH'
+  | 'PROVING_JOB_ID'
+  | 'P2P_ID'
+  | 'P2P_REQ_RESP_BATCH_REQUESTS_COUNT'
+  | 'TARGET_ADDRESS'
+  | 'MANA_USED'
+  | 'TOTAL_INSTRUCTIONS'];
+
 /** Global registry of attributes */
-type AttributesType = Partial<Record<ValuesOf<typeof Attributes>, AttributeValue>>;
-export type { AttributesType };
+export type AttributesType = Partial<Record<AttributeNames, AttributeValue>>;
 
-/** Global registry of metrics */
-type MetricsType = (typeof Metrics)[keyof typeof Metrics];
-export type { MetricsType };
+export type AllowedAttributeNames = Exclude<AttributeNames, BannedMetricAttributeNames>;
 
-export type Gauge = OtelGauge<AttributesType>;
-export type Histogram = OtelHistogram<AttributesType>;
-export type UpDownCounter = OtelUpDownCounter<AttributesType>;
-export type ObservableGauge = OtelObservableGauge<AttributesType>;
-export type ObservableUpDownCounter = OtelObservableUpDownCounter<AttributesType>;
-export type ObservableResult = OtelObservableResult<AttributesType>;
-export type BatchObservableResult = OtelBatchObservableResult<AttributesType>;
+/** Subset of attributes allowed to be added to metrics */
+export type MetricAttributesType = Partial<Record<AllowedAttributeNames, AttributeValue>>;
+
+/** Re-export MetricDefinition for convenience */
+export type { MetricDefinition } from './metrics.js';
+
+export type Gauge = OtelGauge<MetricAttributesType>;
+export type Histogram = OtelHistogram<MetricAttributesType>;
+export type UpDownCounter = OtelUpDownCounter<MetricAttributesType>;
+export type ObservableGauge = OtelObservableGauge<MetricAttributesType>;
+export type ObservableUpDownCounter = OtelObservableUpDownCounter<MetricAttributesType>;
+export type ObservableResult = OtelObservableResult<MetricAttributesType>;
+export type BatchObservableResult = OtelBatchObservableResult<MetricAttributesType>;
 
 export type { Tracer };
 
@@ -49,17 +81,15 @@ export type { Tracer };
 export interface Meter {
   /**
    * Creates a new gauge instrument. A gauge is a metric that represents a single numerical value that can arbitrarily go up and down.
-   * @param name - The name of the gauge
-   * @param options - The options for the gauge
+   * @param metric - The metric definition
    */
-  createGauge(name: MetricsType, options?: MetricOptions): Gauge;
+  createGauge(metric: MetricDefinition): Gauge;
 
   /**
-   * Creates a new gauge instrument. A gauge is a metric that represents a single numerical value that can arbitrarily go up and down.
-   * @param name - The name of the gauge
-   * @param options - The options for the gauge
+   * Creates a new observable gauge instrument. A gauge is a metric that represents a single numerical value that can arbitrarily go up and down.
+   * @param metric - The metric definition
    */
-  createObservableGauge(name: MetricsType, options?: MetricOptions): ObservableGauge;
+  createObservableGauge(metric: MetricDefinition): ObservableGauge;
 
   addBatchObservableCallback(
     callback: BatchObservableCallback<AttributesType>,
@@ -73,24 +103,22 @@ export interface Meter {
 
   /**
    * Creates a new histogram instrument. A histogram is a metric that samples observations (usually things like request durations or response sizes) and counts them in configurable buckets.
-   * @param name - The name of the histogram
-   * @param options - The options for the histogram
+   * @param metric - The metric definition
+   * @param extraOptions - Optional extra options (e.g., advice for bucket boundaries)
    */
-  createHistogram(name: MetricsType, options?: MetricOptions): Histogram;
+  createHistogram(metric: MetricDefinition, extraOptions?: Partial<MetricOptions>): Histogram;
 
   /**
    * Creates a new counter instrument. A counter can go up or down with a delta from the previous value.
-   * @param name - The name of the counter
-   * @param options - The options for the counter
+   * @param metric - The metric definition
    */
-  createUpDownCounter(name: MetricsType, options?: MetricOptions): UpDownCounter;
+  createUpDownCounter(metric: MetricDefinition): UpDownCounter;
 
   /**
-   * Creates a new gauge instrument. A gauge is a metric that represents a single numerical value that can arbitrarily go up and down.
-   * @param name - The name of the gauge
-   * @param options - The options for the gauge
+   * Creates a new observable up/down counter instrument.
+   * @param metric - The metric definition
    */
-  createObservableUpDownCounter(name: MetricsType, options?: MetricOptions): ObservableUpDownCounter;
+  createObservableUpDownCounter(metric: MetricDefinition): ObservableUpDownCounter;
 }
 
 /**
@@ -122,6 +150,27 @@ export interface TelemetryClient {
    * Flushes the telemetry client.
    */
   flush(): Promise<void>;
+
+  /**
+   * Updates what telemetry is exported to the public collector
+   */
+  setExportedPublicTelemetry(prefixes: string[]): void;
+
+  /**
+   * Updates the roles that would share telemetry (if enabled)
+   */
+  setPublicTelemetryCollectFrom(roles: string[]): void;
+
+  /**
+   * Get current trace context as an opaque string for propagation.
+   * Returns the W3C traceparent header value if a trace is active, undefined otherwise.
+   */
+  getTraceContext(): string | undefined;
+
+  /**
+   * Recreates a context propagated by a remote system
+   */
+  extractPropagatedContext(traceContext: string): Context | undefined;
 }
 
 /** Objects that adhere to this interface can use @trackSpan */
@@ -165,25 +214,37 @@ export function trackSpan<T extends Traceable, F extends (...args: any[]) => any
       // run originalMethod wrapped in an active span
       // "active" means the span will be alive for the duration of the function execution
       // and if any other spans are started during the execution of originalMethod, they will be children of this span
-      // behind the scenes this uses AsyncLocalStorage https://nodejs.org/dist/latest-v18.x/docs/api/async_context.html
-      return this.tracer.startActiveSpan(name, async (span: Span) => {
-        span.setAttributes(currentAttrs ?? {});
-
-        try {
-          const res = await originalMethod.call(this, ...args);
-          const extraAttrs = extraAttributes?.call(this, res);
-          span.setAttributes(extraAttrs ?? {});
-          return res;
-        } catch (err) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: String(err),
-          });
-          throw err;
-        } finally {
-          span.end();
-        }
-      });
+      // behind the scenes this uses AsyncLocalStorage https://nodejs.org/dist/latest-v22.x/docs/api/async_context.html
+      return this.tracer.startActiveSpan(
+        name,
+        {
+          attributes: currentAttrs,
+        },
+        async (span: Span) => {
+          try {
+            const res = await originalMethod.call(this, ...args);
+            const extraAttrs = extraAttributes?.call(this, res);
+            span.setAttributes(extraAttrs ?? {});
+            span.setStatus({
+              code: SpanStatusCode.OK,
+            });
+            return res;
+          } catch (err) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: String(err),
+            });
+
+            if (typeof err === 'string' || (err && err instanceof Error)) {
+              span.recordException(err);
+            }
+
+            throw err;
+          } finally {
+            span.end();
+          }
+        },
+      );
     } as F;
   };
 }
@@ -227,41 +288,57 @@ export function wrapCallbackInSpan<F extends (...args: any[]) => any>(
 export function runInSpan<A extends any[], R>(
   tracer: Tracer | string,
   spanName: string,
-  callback: (span: Span, ...args: A) => R,
-): (...args: A) => R {
-  return (...args: A): R => {
+  callback: (span: Span, ...args: A) => Promise<R>,
+): (...args: A) => Promise<R> {
+  return (...args: A): Promise<R> => {
     const actualTracer = typeof tracer === 'string' ? getTelemetryClient().getTracer(tracer) : tracer;
-    return actualTracer.startActiveSpan(spanName, (span: Span): R => {
-      let deferSpanEnd = false;
+    return actualTracer.startActiveSpan(spanName, async (span: Span): Promise<R> => {
       try {
-        const res = callback(span, ...args);
-        if (isPromise(res)) {
-          deferSpanEnd = true;
-          return res
-            .catch(err => {
-              span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: String(err),
-              });
-              throw err;
-            })
-            .finally(() => {
-              span.end();
-            }) as R;
-        } else {
-          return res;
-        }
+        const res = await callback(span, ...args);
+        span.setStatus({
+          code: SpanStatusCode.OK,
+        });
+
+        return res;
       } catch (err) {
         span.setStatus({
           code: SpanStatusCode.ERROR,
           message: String(err),
         });
+        if (typeof err === 'string' || (err && err instanceof Error)) {
+          span.recordException(err);
+        }
         throw err;
       } finally {
-        if (!deferSpanEnd) {
-          span.end();
-        }
+        span.end();
       }
     });
   };
 }
+
+/**
+ * Execute a callback within a span immediately (for one-off traced calls).
+ * Unlike runInSpan which returns a reusable function, this executes right away.
+ */
+export function execInSpan<R>(
+  tracer: Tracer | string,
+  spanName: string,
+  callback: (span: Span) => Promise<R>,
+): Promise<R> {
+  const actualTracer = typeof tracer === 'string' ? getTelemetryClient().getTracer(tracer) : tracer;
+  return actualTracer.startActiveSpan(spanName, async (span: Span): Promise<R> => {
+    try {
+      const res = await callback(span);
+      span.setStatus({ code: SpanStatusCode.OK });
+      return res;
+    } catch (err) {
+      span.setStatus({ code: SpanStatusCode.ERROR, message: String(err) });
+      if (typeof err === 'string' || (err && err instanceof Error)) {
+        span.recordException(err);
+      }
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}

package/src/vendor/otel-pino-stream.ts

@@ -23,9 +23,6 @@ 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.
@@ -173,7 +170,7 @@ export class OTelPinoStream extends Writable {
         return;
       }
 
-      // Parse, and handle edge cases similar to how `pino-abtract-transport` does:
+      // Parse, and handle edge cases similar to how `pino-abstract-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;

package/src/wrappers/fetch.ts

@@ -15,38 +15,31 @@ import { ATTR_JSONRPC_METHOD, ATTR_JSONRPC_REQUEST_ID } from '../vendor/attribut
  * @returns A fetch function.
  */
 export function makeTracedFetch(retries: number[], defaultNoRetry: boolean, fetch = defaultFetch, log?: Logger) {
-  return (
-    host: string,
-    rpcMethod: string,
-    body: any,
-    useApiEndpoints: boolean,
-    extraHeaders: Record<string, string> = {},
-    noRetry?: boolean,
-  ) => {
+  return (host: string, body: unknown, extraHeaders: Record<string, string> = {}, noRetry?: boolean) => {
     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: any) {
-          span.setStatus({ code: SpanStatusCode.ERROR, message: err?.message ?? String(err) });
-          throw err;
-        } finally {
-          span.end();
+    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);
+        return await retry(
+          () => fetch(host, body, headers, noRetry ?? defaultNoRetry),
+          `JsonRpcClient request to ${host}`,
+          makeBackoff(retries),
+          log,
+          false,
+        );
+      } catch (err: any) {
+        span.setStatus({ code: SpanStatusCode.ERROR, message: err?.message ?? String(err) });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
   };
 }

package/src/wrappers/json_rpc_server.ts

@@ -6,7 +6,7 @@ import { getOtelJsonRpcPropagationMiddleware } from '../otel_propagation.js';
 export function createTracedJsonRpcServer<T extends object = any>(
   handler: T,
   schema: ApiSchemaFor<T>,
-  options: Partial<SafeJsonRpcServerOptions> = {},
+  options: SafeJsonRpcServerOptions = {},
 ) {
   return createSafeJsonRpcServer(handler, schema, {
     ...options,

package/src/wrappers/l2_block_stream.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import {
   type L2BlockSource,
@@ -10,7 +11,10 @@ import { type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client'
 /** Extends an L2BlockStream with a tracer to create a new trace per iteration. */
 export class TraceableL2BlockStream extends L2BlockStream implements Traceable {
   constructor(
-    l2BlockSource: Pick<L2BlockSource, 'getBlocks' | 'getBlockHeader' | 'getL2Tips'>,
+    l2BlockSource: Pick<
+      L2BlockSource,
+      'getBlocks' | 'getBlockHeader' | 'getL2Tips' | 'getCheckpoints' | 'getCheckpointedBlocks'
+    >,
     localData: L2BlockStreamLocalDataProvider,
     handler: L2BlockStreamEventHandler,
     public readonly tracer: Tracer,
@@ -20,7 +24,7 @@ export class TraceableL2BlockStream extends L2BlockStream implements Traceable {
       proven?: boolean;
       pollIntervalMS?: number;
       batchSize?: number;
-      startingBlock?: number;
+      startingBlock?: BlockNumber;
     } = {},
   ) {
     super(l2BlockSource, localData, handler, log, opts);

package/dest/event_loop_monitor.d.ts

@@ -1,18 +0,0 @@
-import { type Meter } from './telemetry.js';
-/**
- * Detector for custom Aztec attributes
- */
-export declare class EventLoopMonitor {
-    private meter;
-    private eventLoopDelayGauges;
-    private eventLoopUilization;
-    private eventLoopTime;
-    private started;
-    private lastELU;
-    private eventLoopDelay;
-    constructor(meter: Meter);
-    start(): void;
-    stop(): void;
-    private measure;
-}
-//# sourceMappingURL=event_loop_monitor.d.ts.map

package/dest/event_loop_monitor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"event_loop_monitor.d.ts","sourceRoot":"","sources":["../src/event_loop_monitor.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,KAAK,EAIX,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,qBAAa,gBAAgB;IAmBf,OAAO,CAAC,KAAK;IAlBzB,OAAO,CAAC,oBAAoB,CAQ1B;IAEF,OAAO,CAAC,mBAAmB,CAAkB;IAC7C,OAAO,CAAC,aAAa,CAAgB;IAErC,OAAO,CAAC,OAAO,CAAS;IAExB,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,cAAc,CAAoB;gBAEtB,KAAK,EAAE,KAAK;IAgChC,KAAK,IAAI,IAAI;IAab,IAAI,IAAI,IAAI;IAaZ,OAAO,CAAC,OAAO,CAyBb;CACH"}

package/dest/event_loop_monitor.js

@@ -1,93 +0,0 @@
-import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
-import * as Attributes from './attributes.js';
-import * as Metrics from './metrics.js';
-import { ValueType } from './telemetry.js';
-/**
- * Detector for custom Aztec attributes
- */ export class EventLoopMonitor {
-    meter;
-    eventLoopDelayGauges;
-    eventLoopUilization;
-    eventLoopTime;
-    started;
-    lastELU;
-    eventLoopDelay;
-    constructor(meter){
-        this.meter = meter;
-        this.started = false;
-        this.measure = (obs)=>{
-            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();
-        };
-        const nsObsGauge = (name, description)=>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() {
-        if (this.started) {
-            return;
-        }
-        this.lastELU = performance.eventLoopUtilization();
-        this.eventLoopDelay.enable();
-        this.meter.addBatchObservableCallback(this.measure, [
-            this.eventLoopUilization,
-            ...Object.values(this.eventLoopDelayGauges)
-        ]);
-    }
-    stop() {
-        if (!this.started) {
-            return;
-        }
-        this.meter.removeBatchObservableCallback(this.measure, [
-            this.eventLoopUilization,
-            ...Object.values(this.eventLoopDelayGauges)
-        ]);
-        this.eventLoopDelay.disable();
-        this.eventLoopDelay.reset();
-        this.lastELU = undefined;
-    }
-    measure;
-}

package/src/event_loop_monitor.ts

@@ -1,119 +0,0 @@
-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();
-  };
-}