@aztec/telemetry-client 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/monitored_batch_span_processor.ts

@@ -0,0 +1,93 @@
+import type { Logger } from '@aztec/foundation/log';
+
+import { type Context, SpanStatusCode } from '@opentelemetry/api';
+import { hrTimeToMilliseconds } from '@opentelemetry/core';
+import type { SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { BatchSpanProcessor, type BufferConfig, type ReadableSpan, type Span } from '@opentelemetry/sdk-trace-node';
+
+/** Minimum interval between drop warnings to avoid log spam. */
+const DROP_WARNING_INTERVAL_MS = 30_000;
+
+const DEFAULT_MIN_TRACE_DURATION_MS = 10;
+
+export type MonitoredBatchSpanProcessorConfig = BufferConfig & {
+  minTraceDurationMs?: number;
+};
+
+/**
+ * Wraps BatchSpanProcessor to emit warnings when spans are dropped due to a full queue.
+ * The standard BatchSpanProcessor silently discards spans when its internal queue reaches
+ * maxQueueSize, making telemetry data loss invisible to operators.
+ */
+export class MonitoredBatchSpanProcessor extends BatchSpanProcessor {
+  private readonly maxQueueSize: number;
+  private readonly minTraceDurationMs: number;
+  private readonly log: Logger;
+
+  private approxQueueSize = 0;
+  private droppedSinceLastWarning = 0;
+  private totalDropped = 0;
+  private lastWarningTime = 0;
+
+  constructor(exporter: SpanExporter, log: Logger, config?: MonitoredBatchSpanProcessorConfig) {
+    const maxQueueSize = config?.maxQueueSize ?? 2048;
+    super(exporter, { ...config, maxQueueSize });
+    this.maxQueueSize = maxQueueSize;
+    this.minTraceDurationMs = Math.max(0, config?.minTraceDurationMs ?? DEFAULT_MIN_TRACE_DURATION_MS);
+    this.log = log;
+  }
+
+  override onStart(span: Span, parentContext: Context): void {
+    super.onStart(span, parentContext);
+  }
+
+  override onEnd(span: ReadableSpan): void {
+    if (this.shouldDropShortSpan(span)) {
+      return;
+    }
+
+    if (this.approxQueueSize >= this.maxQueueSize) {
+      this.droppedSinceLastWarning++;
+      this.totalDropped++;
+      this.maybeLogDropWarning();
+    } else {
+      this.approxQueueSize++;
+    }
+    super.onEnd(span);
+  }
+
+  override async forceFlush(): Promise<void> {
+    await super.forceFlush();
+    this.approxQueueSize = 0;
+  }
+
+  override async shutdown(): Promise<void> {
+    if (this.totalDropped > 0) {
+      this.log.warn(`BatchSpanProcessor shutting down with ${this.totalDropped} total spans dropped`, {
+        totalDropped: this.totalDropped,
+      });
+    }
+    await super.shutdown();
+  }
+
+  private shouldDropShortSpan(span: ReadableSpan): boolean {
+    return (
+      this.minTraceDurationMs > 0 &&
+      span.status.code !== SpanStatusCode.ERROR &&
+      hrTimeToMilliseconds(span.duration) < this.minTraceDurationMs
+    );
+  }
+
+  private maybeLogDropWarning(): void {
+    const now = Date.now();
+    if (now - this.lastWarningTime >= DROP_WARNING_INTERVAL_MS) {
+      this.log.warn(
+        `BatchSpanProcessor dropping spans: queue full (maxQueueSize=${this.maxQueueSize}). ` +
+          `${this.droppedSinceLastWarning} dropped since last warning, ${this.totalDropped} total.`,
+        { droppedSinceLastWarning: this.droppedSinceLastWarning, totalDropped: this.totalDropped },
+      );
+      this.droppedSinceLastWarning = 0;
+      this.lastWarningTime = now;
+    }
+  }
+}

package/src/nodejs_metrics_monitor.ts

@@ -0,0 +1,135 @@
+import type { Observable } from '@opentelemetry/api';
+import { type EventLoopUtilization, type IntervalHistogram, monitorEventLoopDelay, performance } from 'node:perf_hooks';
+
+import * as Attributes from './attributes.js';
+import { createUpDownCounterWithDefault } from './metric-utils.js';
+import * as Metrics from './metrics.js';
+import type { BatchObservableResult, Meter, ObservableGauge, UpDownCounter } from './telemetry.js';
+
+/** Monitors Node.js runtime metrics */
+export class NodejsMetricsMonitor {
+  private eventLoopDelayGauges: {
+    min: ObservableGauge;
+    max: ObservableGauge;
+    mean: ObservableGauge;
+    stddev: ObservableGauge;
+    p50: ObservableGauge;
+    p90: ObservableGauge;
+    p99: ObservableGauge;
+  };
+
+  // skip `rss` because that's already tracked by @opentelemetry/host-metrics
+  // description of each field here https://nodejs.org/api/process.html#processmemoryusage
+  private memoryGauges: Record<Exclude<keyof NodeJS.MemoryUsage, 'rss'>, ObservableGauge>;
+
+  private eventLoopUilization: ObservableGauge;
+  private eventLoopTime: UpDownCounter;
+
+  private started = false;
+
+  private lastELU: EventLoopUtilization | undefined;
+  private eventLoopDelay: IntervalHistogram;
+
+  constructor(private meter: Meter) {
+    this.eventLoopDelayGauges = {
+      min: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MIN),
+      mean: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MEAN),
+      max: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_MAX),
+      stddev: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_STDDEV),
+      p50: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P50),
+      p90: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P90),
+      p99: meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_DELAY_P99),
+    };
+
+    this.eventLoopUilization = meter.createObservableGauge(Metrics.NODEJS_EVENT_LOOP_UTILIZATION);
+    this.eventLoopTime = createUpDownCounterWithDefault(meter, Metrics.NODEJS_EVENT_LOOP_TIME, {
+      [Attributes.NODEJS_EVENT_LOOP_STATE]: ['idle', 'active'],
+    });
+    this.eventLoopDelay = monitorEventLoopDelay();
+
+    this.memoryGauges = {
+      heapUsed: meter.createObservableGauge(Metrics.NODEJS_MEMORY_HEAP_USAGE),
+      heapTotal: meter.createObservableGauge(Metrics.NODEJS_MEMORY_HEAP_TOTAL),
+      arrayBuffers: meter.createObservableGauge(Metrics.NODEJS_MEMORY_BUFFER_USAGE),
+      external: meter.createObservableGauge(Metrics.NODEJS_MEMORY_NATIVE_USAGE),
+    };
+  }
+
+  start(): void {
+    if (this.started) {
+      return;
+    }
+
+    this.lastELU = performance.eventLoopUtilization();
+    this.eventLoopDelay.enable();
+    this.meter.addBatchObservableCallback(this.measure, [
+      this.eventLoopUilization,
+      ...Object.values(this.eventLoopDelayGauges),
+      ...Object.values(this.memoryGauges),
+    ]);
+  }
+
+  stop(): void {
+    if (!this.started) {
+      return;
+    }
+    this.meter.removeBatchObservableCallback(this.measure, [
+      this.eventLoopUilization,
+      ...Object.values(this.eventLoopDelayGauges),
+      ...Object.values(this.memoryGauges),
+    ]);
+    this.eventLoopDelay.disable();
+    this.eventLoopDelay.reset();
+    this.lastELU = undefined;
+  }
+
+  private measure = (obs: BatchObservableResult): void => {
+    this.measureMemoryUsage(obs);
+    this.measureEventLoopDelay(obs);
+  };
+
+  private measureMemoryUsage = (observer: BatchObservableResult) => {
+    const mem = process.memoryUsage();
+
+    observer.observe(this.memoryGauges.heapUsed, mem.heapUsed);
+    observer.observe(this.memoryGauges.heapTotal, mem.heapTotal);
+    observer.observe(this.memoryGauges.arrayBuffers, mem.arrayBuffers);
+    observer.observe(this.memoryGauges.external, mem.external);
+  };
+
+  private measureEventLoopDelay = (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.trunc(delta.idle), { [Attributes.NODEJS_EVENT_LOOP_STATE]: 'idle' });
+    this.eventLoopTime.add(Math.trunc(delta.active), { [Attributes.NODEJS_EVENT_LOOP_STATE]: 'active' });
+
+    safeObserveInt(obs, this.eventLoopDelayGauges.min, this.eventLoopDelay.min);
+    safeObserveInt(obs, this.eventLoopDelayGauges.mean, this.eventLoopDelay.mean);
+    safeObserveInt(obs, this.eventLoopDelayGauges.max, this.eventLoopDelay.max);
+    safeObserveInt(obs, this.eventLoopDelayGauges.stddev, this.eventLoopDelay.stddev);
+    safeObserveInt(obs, this.eventLoopDelayGauges.p50, this.eventLoopDelay.percentile(50));
+    safeObserveInt(obs, this.eventLoopDelayGauges.p90, this.eventLoopDelay.percentile(90));
+    safeObserveInt(obs, this.eventLoopDelayGauges.p99, this.eventLoopDelay.percentile(99));
+
+    this.eventLoopDelay.reset();
+  };
+}
+
+function safeObserveInt(observer: BatchObservableResult, metric: Observable, value: number, attrs?: object) {
+  // discard NaN, Infinity, -Infinity
+  if (!Number.isFinite(value)) {
+    return;
+  }
+
+  observer.observe(metric, Math.trunc(value), attrs);
+}

package/src/noop.ts

@@ -1,10 +1,63 @@
-import { type Meter, type Span, type SpanContext, type Tracer, createNoopMeter } from '@opentelemetry/api';
+import { type Context, type Span, type SpanContext, type Tracer, createNoopMeter } from '@opentelemetry/api';
 
-import type { TelemetryClient } from './telemetry.js';
+import type { MetricDefinition } from './metrics.js';
+import type {
+  Gauge,
+  Histogram,
+  Meter,
+  ObservableGauge,
+  ObservableUpDownCounter,
+  TelemetryClient,
+  UpDownCounter,
+} from './telemetry.js';
+
+/** A no-op meter that implements our custom Meter interface */
+class NoopMeter implements Meter {
+  private otelMeter = createNoopMeter();
+
+  createGauge(_metric: MetricDefinition): Gauge {
+    return this.otelMeter.createGauge('');
+  }
+
+  createObservableGauge(_metric: MetricDefinition): ObservableGauge {
+    return this.otelMeter.createObservableGauge('');
+  }
+
+  createHistogram(_metric: MetricDefinition, _extraOptions?: Parameters<Meter['createHistogram']>[1]): Histogram {
+    return this.otelMeter.createHistogram('');
+  }
+
+  createUpDownCounter(_metric: MetricDefinition): UpDownCounter {
+    return this.otelMeter.createUpDownCounter('');
+  }
+
+  createObservableUpDownCounter(_metric: MetricDefinition): ObservableUpDownCounter {
+    return this.otelMeter.createObservableUpDownCounter('');
+  }
+
+  addBatchObservableCallback(
+    callback: Parameters<Meter['addBatchObservableCallback']>[0],
+    observables: Parameters<Meter['addBatchObservableCallback']>[1],
+  ): void {
+    this.otelMeter.addBatchObservableCallback(callback, observables);
+  }
+
+  removeBatchObservableCallback(
+    callback: Parameters<Meter['removeBatchObservableCallback']>[0],
+    observables: Parameters<Meter['removeBatchObservableCallback']>[1],
+  ): void {
+    this.otelMeter.removeBatchObservableCallback(callback, observables);
+  }
+}
 
 export class NoopTelemetryClient implements TelemetryClient {
+  private meter = new NoopMeter();
+
+  setExportedPublicTelemetry(_prefixes: string[]): void {}
+  setPublicTelemetryCollectFrom(_roles: string[]): void {}
+
   getMeter(): Meter {
-    return createNoopMeter();
+    return this.meter;
   }
 
   getTracer(): Tracer {
@@ -22,6 +75,14 @@ export class NoopTelemetryClient implements TelemetryClient {
   isEnabled() {
     return false;
   }
+
+  getTraceContext(): string | undefined {
+    return undefined;
+  }
+
+  extractPropagatedContext(_traceContext: string): Context | undefined {
+    return undefined;
+  }
 }
 
 // @opentelemetry/api internally uses NoopTracer and NoopSpan but they're not exported
@@ -32,7 +93,7 @@ export class NoopTracer implements Tracer {
     return new NoopSpan();
   }
 
-  startActiveSpan<F extends (...args: any[]) => any>(_name: string, ...args: (unknown | F)[]): ReturnType<F> {
+  startActiveSpan<F extends (...args: any[]) => any>(_name: string, ...args: unknown[]): ReturnType<F> {
     // there are three different signatures for startActiveSpan, grab the function, we don't care about the rest
     const fn = args.find(arg => typeof arg === 'function') as F;
     return fn(new NoopSpan());

package/src/otel.ts

@@ -1,16 +1,20 @@
 import { type LogData, type Logger, addLogDataHandler } from '@aztec/foundation/log';
 
 import {
+  type Context,
   DiagConsoleLogger,
   DiagLogLevel,
-  type Meter,
+  type Meter as OtelMeter,
+  ROOT_CONTEXT,
   type Tracer,
   type TracerProvider,
   context,
   diag,
   isSpanContextValid,
+  propagation,
   trace,
 } from '@opentelemetry/api';
+import { W3CTraceContextPropagator } from '@opentelemetry/core';
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { HostMetrics } from '@opentelemetry/host-metrics';
@@ -24,22 +28,72 @@ import {
   type PeriodicExportingMetricReaderOptions,
   View,
 } from '@opentelemetry/sdk-metrics';
-import { BatchSpanProcessor, NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
 
 import type { TelemetryClientConfig } from './config.js';
-import { EventLoopMonitor } from './event_loop_monitor.js';
-import { OtelFilterMetricExporter } from './otel_filter_metric_exporter.js';
+import { toMetricOptions } from './metric-utils.js';
+import type { MetricDefinition } from './metrics.js';
+import { MonitoredBatchSpanProcessor } from './monitored_batch_span_processor.js';
+import { NodejsMetricsMonitor } from './nodejs_metrics_monitor.js';
+import { OtelFilterMetricExporter, PublicOtelFilterMetricExporter } from './otel_filter_metric_exporter.js';
 import { registerOtelLoggerProvider } from './otel_logger_provider.js';
 import { getOtelResource } from './otel_resource.js';
-import type { TelemetryClient } from './telemetry.js';
+import type {
+  Gauge,
+  Histogram,
+  Meter,
+  ObservableGauge,
+  ObservableUpDownCounter,
+  TelemetryClient,
+  UpDownCounter,
+} from './telemetry.js';
+
+/** Wraps an OpenTelemetry Meter to implement our custom Meter interface */
+class WrappedMeter implements Meter {
+  constructor(private otelMeter: OtelMeter) {}
+
+  createGauge(metric: MetricDefinition): Gauge {
+    return this.otelMeter.createGauge(metric.name, toMetricOptions(metric));
+  }
+
+  createObservableGauge(metric: MetricDefinition): ObservableGauge {
+    return this.otelMeter.createObservableGauge(metric.name, toMetricOptions(metric));
+  }
+
+  createHistogram(metric: MetricDefinition, extraOptions?: Parameters<Meter['createHistogram']>[1]): Histogram {
+    return this.otelMeter.createHistogram(metric.name, { ...toMetricOptions(metric), ...extraOptions });
+  }
+
+  createUpDownCounter(metric: MetricDefinition): UpDownCounter {
+    return this.otelMeter.createUpDownCounter(metric.name, toMetricOptions(metric));
+  }
+
+  createObservableUpDownCounter(metric: MetricDefinition): ObservableUpDownCounter {
+    return this.otelMeter.createObservableUpDownCounter(metric.name, toMetricOptions(metric));
+  }
+
+  addBatchObservableCallback(
+    callback: Parameters<Meter['addBatchObservableCallback']>[0],
+    observables: Parameters<Meter['addBatchObservableCallback']>[1],
+  ): void {
+    this.otelMeter.addBatchObservableCallback(callback, observables);
+  }
+
+  removeBatchObservableCallback(
+    callback: Parameters<Meter['removeBatchObservableCallback']>[0],
+    observables: Parameters<Meter['removeBatchObservableCallback']>[1],
+  ): void {
+    this.otelMeter.removeBatchObservableCallback(callback, observables);
+  }
+}
 
 export type OpenTelemetryClientFactory = (resource: IResource, log: Logger) => OpenTelemetryClient;
 
 export class OpenTelemetryClient implements TelemetryClient {
   hostMetrics: HostMetrics | undefined;
-  eventLoopMonitor: EventLoopMonitor | undefined;
-  private meters: Map<string, Meter> = new Map<string, Meter>();
+  nodejsMetricsMonitor: NodejsMetricsMonitor | undefined;
+  private meters: Map<string, WrappedMeter> = new Map<string, WrappedMeter>();
   private tracers: Map<string, Tracer> = new Map<string, Tracer>();
 
   protected constructor(
@@ -47,13 +101,23 @@ export class OpenTelemetryClient implements TelemetryClient {
     private meterProvider: MeterProvider,
     private traceProvider: TracerProvider,
     private loggerProvider: LoggerProvider | undefined,
+    private publicMetricExporter: PublicOtelFilterMetricExporter | undefined,
     private log: Logger,
   ) {}
 
+  setExportedPublicTelemetry(metrics: string[]): void {
+    this.publicMetricExporter?.setMetricPrefixes(metrics);
+  }
+
+  setPublicTelemetryCollectFrom(roles: string[]): void {
+    this.publicMetricExporter?.setAllowedRoles(roles);
+  }
+
   getMeter(name: string): Meter {
     let meter = this.meters.get(name);
     if (!meter) {
-      meter = this.meterProvider.getMeter(name, this.resource.attributes[ATTR_SERVICE_VERSION] as string);
+      const otelMeter = this.meterProvider.getMeter(name, this.resource.attributes[ATTR_SERVICE_VERSION] as string);
+      meter = new WrappedMeter(otelMeter);
       this.meters.set(name, meter);
     }
     return meter;
@@ -91,12 +155,13 @@ export class OpenTelemetryClient implements TelemetryClient {
       meterProvider: this.meterProvider,
     });
 
-    this.eventLoopMonitor = new EventLoopMonitor(
+    const nodejsMeter = new WrappedMeter(
       this.meterProvider.getMeter(this.resource.attributes[ATTR_SERVICE_NAME] as string),
     );
+    this.nodejsMetricsMonitor = new NodejsMetricsMonitor(nodejsMeter);
 
     this.hostMetrics.start();
-    this.eventLoopMonitor.start();
+    this.nodejsMetricsMonitor.start();
   }
 
   public isEnabled() {
@@ -112,7 +177,7 @@ export class OpenTelemetryClient implements TelemetryClient {
   }
 
   public async stop() {
-    this.eventLoopMonitor?.stop();
+    this.nodejsMetricsMonitor?.stop();
 
     const flushAndShutdown = async (provider?: { forceFlush: () => Promise<void>; shutdown: () => Promise<void> }) => {
       if (!provider) {
@@ -129,18 +194,46 @@ export class OpenTelemetryClient implements TelemetryClient {
     ]);
   }
 
+  public getTraceContext(): string | undefined {
+    const carrier: Record<string, string> = {};
+    propagation.inject(context.active(), carrier);
+    return carrier['traceparent'];
+  }
+
+  public extractPropagatedContext(traceContext: string): Context {
+    const extractedContext = propagation.extract(ROOT_CONTEXT, {
+      traceparent: traceContext,
+    });
+    return extractedContext;
+  }
+
   public static createMeterProvider(
     resource: IResource,
-    options: Partial<PeriodicExportingMetricReaderOptions>,
+    exporters: Array<PeriodicExportingMetricReaderOptions>,
   ): MeterProvider {
     return new MeterProvider({
       resource,
-      readers: options.exporter
-        ? [new PeriodicExportingMetricReader(options as PeriodicExportingMetricReaderOptions)]
-        : [],
+      readers: exporters.map(options => new PeriodicExportingMetricReader(options)),
 
       views: [
         // Every histogram matching the selector (type + unit) gets these custom buckets assigned
+        new View({
+          instrumentType: InstrumentType.HISTOGRAM,
+          instrumentUnit: 'Mmana',
+          aggregation: new ExplicitBucketHistogramAggregation(
+            [0.1, 0.5, 1, 2, 4, 8, 10, 25, 50, 100, 500, 1000, 5000, 10000],
+            true,
+          ),
+        }),
+        new View({
+          instrumentType: InstrumentType.HISTOGRAM,
+          instrumentUnit: 'tx',
+          aggregation: new ExplicitBucketHistogramAggregation(
+            // TPS
+            [0.1 * 36, 0.2 * 36, 0.5 * 36, 1 * 36, 2 * 36, 5 * 36, 10 * 36, 15 * 36].map(Math.ceil),
+            true,
+          ),
+        }),
         new View({
           instrumentType: InstrumentType.HISTOGRAM,
           instrumentUnit: 's',
@@ -242,6 +335,36 @@ export class OpenTelemetryClient implements TelemetryClient {
             true,
           ),
         }),
+        // L1 gas prices in gwei: priority fees ~0.01-10, base fees ~1-500, spikes to 1000+
+        new View({
+          instrumentType: InstrumentType.HISTOGRAM,
+          instrumentUnit: 'gwei',
+          aggregation: new ExplicitBucketHistogramAggregation(
+            [0.1, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1_000],
+            true,
+          ),
+        }),
+        // L1 gas consumption: tx gas 100k-30M, calldata/blob gas varies
+        new View({
+          instrumentType: InstrumentType.HISTOGRAM,
+          instrumentUnit: 'gas',
+          aggregation: new ExplicitBucketHistogramAggregation(
+            [
+              10_000, 50_000, 100_000, 250_000, 500_000, 1_000_000, 2_000_000, 5_000_000, 10_000_000, 15_000_000,
+              30_000_000,
+            ],
+            true,
+          ),
+        }),
+        // L1 tx total fee in ETH: typically 0.001 - 1 ETH
+        new View({
+          instrumentType: InstrumentType.HISTOGRAM,
+          instrumentUnit: 'eth',
+          aggregation: new ExplicitBucketHistogramAggregation(
+            [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10],
+            true,
+          ),
+        }),
       ],
     });
   }
@@ -251,26 +374,68 @@ export class OpenTelemetryClient implements TelemetryClient {
       const tracerProvider = new NodeTracerProvider({
         resource,
         spanProcessors: config.tracesCollectorUrl
-          ? [new BatchSpanProcessor(new OTLPTraceExporter({ url: config.tracesCollectorUrl.href }))]
+          ? [
+              new MonitoredBatchSpanProcessor(new OTLPTraceExporter({ url: config.tracesCollectorUrl.href }), log, {
+                maxQueueSize: config.otelBspMaxQueueSize,
+                minTraceDurationMs: config.otelMinTraceDurationMs,
+              }),
+            ]
           : [],
       });
 
-      tracerProvider.register();
-
-      const meterProvider = OpenTelemetryClient.createMeterProvider(resource, {
-        exporter: config.metricsCollectorUrl
-          ? new OtelFilterMetricExporter(
-              new OTLPMetricExporter({ url: config.metricsCollectorUrl.href }),
-              config.otelExcludeMetrics ?? [],
-            )
-          : undefined,
-        exportTimeoutMillis: config.otelExportTimeoutMs,
-        exportIntervalMillis: config.otelCollectIntervalMs,
+      tracerProvider.register({
+        propagator: new W3CTraceContextPropagator(),
       });
 
+      const exporters: PeriodicExportingMetricReaderOptions[] = [];
+      if (config.metricsCollectorUrl) {
+        // Default to a blacklist that is empty (allow all metrics)
+        let filter: string[] = [];
+        let mode: 'allow' | 'deny' = 'deny';
+        if (config.otelExcludeMetrics.length > 0) {
+          // Implement a blacklist as specified in config
+          log.info(`Excluding metrics from export: ${config.otelExcludeMetrics}`);
+          filter = config.otelExcludeMetrics;
+          mode = 'deny';
+        } else if (config.otelIncludeMetrics.length > 0) {
+          // Implement a whitelist as specified in config
+          log.info(`Including only specified metrics for export: ${config.otelIncludeMetrics}`);
+          filter = config.otelIncludeMetrics;
+          mode = 'allow';
+        }
+        exporters.push({
+          exporter: new OtelFilterMetricExporter(
+            new OTLPMetricExporter({ url: config.metricsCollectorUrl.href }),
+            filter,
+            mode,
+          ),
+          exportTimeoutMillis: config.otelExportTimeoutMs,
+          exportIntervalMillis: config.otelCollectIntervalMs,
+        });
+      }
+
+      let publicExporter: PublicOtelFilterMetricExporter | undefined;
+      if (config.publicMetricsCollectorUrl && !config.publicMetricsOptOut) {
+        log.info(`Exporting public metrics: ${config.publicIncludeMetrics}`, {
+          publicMetrics: config.publicIncludeMetrics,
+          collectorUrl: config.publicMetricsCollectorUrl,
+        });
+        publicExporter = new PublicOtelFilterMetricExporter(
+          config.publicMetricsCollectFrom,
+          new OTLPMetricExporter({ url: config.publicMetricsCollectorUrl.href }),
+          config.publicIncludeMetrics,
+        );
+        exporters.push({
+          exporter: publicExporter,
+          exportTimeoutMillis: config.otelExportTimeoutMs,
+          exportIntervalMillis: config.otelCollectIntervalMs,
+        });
+      }
+
+      const meterProvider = OpenTelemetryClient.createMeterProvider(resource, exporters);
       const loggerProvider = registerOtelLoggerProvider(resource, config.logsCollectorUrl);
 
-      return new OpenTelemetryClient(resource, meterProvider, tracerProvider, loggerProvider, log);
+      return new OpenTelemetryClient(resource, meterProvider, tracerProvider, loggerProvider, publicExporter, log);
     };
   }