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

package/dest/start.js

@@ -0,0 +1,25 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { NoopTelemetryClient } from './noop.js';
+export * from './config.js';
+let initialized = false;
+let telemetry = new NoopTelemetryClient();
+export async function initTelemetryClient(config, bindings) {
+    const log = createLogger('telemetry:client', bindings);
+    if (initialized) {
+        log.warn('Telemetry client has already been initialized once');
+        return telemetry;
+    }
+    if (config.metricsCollectorUrl || config.publicMetricsCollectorUrl || config.tracesCollectorUrl || config.logsCollectorUrl) {
+        log.info(`Using OpenTelemetry client with custom collector`);
+        // Lazy load OpenTelemetry to avoid loading heavy deps at startup
+        const { OpenTelemetryClient } = await import('./otel.js');
+        telemetry = OpenTelemetryClient.createAndStart(config, log);
+    } else {
+        log.info('Using NoopTelemetryClient');
+    }
+    initialized = true;
+    return telemetry;
+}
+export function getTelemetryClient() {
+    return telemetry;
+}

package/dest/telemetry.d.ts

@@ -0,0 +1,149 @@
+import { type AttributeValue, type BatchObservableCallback, type Context, type MetricOptions, type Observable, type BatchObservableResult as OtelBatchObservableResult, type Gauge as OtelGauge, type Histogram as OtelHistogram, type ObservableGauge as OtelObservableGauge, type ObservableResult as OtelObservableResult, type ObservableUpDownCounter as OtelObservableUpDownCounter, type UpDownCounter as OtelUpDownCounter, type Span, type Tracer } from '@opentelemetry/api';
+import type * as Attributes from './attributes.js';
+import type { MetricDefinition } from './metrics.js';
+import type * as VendorAttributes from './vendor/attributes.js';
+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>;
+type AllowedVendorMetricAttributeNames = (typeof VendorAttributes)['ATTR_JSONRPC_METHOD' | 'ATTR_JSONRPC_SERVICE'];
+/**
+ * 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' | 'TARGET_ADDRESS' | 'MANA_USED' | 'TOTAL_INSTRUCTIONS'];
+/** Global registry of attributes */
+export type AttributesType = Partial<Record<AttributeNames, AttributeValue>>;
+export type AllowedAttributeNames = Exclude<AttributeNames, BannedMetricAttributeNames> | AllowedVendorMetricAttributeNames;
+/** 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 };
+/**
+ * A meter that provides instruments for recording metrics.
+ */
+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 metric - The metric definition
+     */
+    createGauge(metric: MetricDefinition): 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(metric: MetricDefinition): ObservableGauge;
+    addBatchObservableCallback(callback: BatchObservableCallback<AttributesType>, observables: Observable<AttributesType>[]): void;
+    removeBatchObservableCallback(callback: BatchObservableCallback<AttributesType>, observables: Observable<AttributesType>[]): void;
+    /**
+     * 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 metric - The metric definition
+     * @param extraOptions - Optional extra options (e.g., advice for bucket boundaries)
+     */
+    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 metric - The metric definition
+     */
+    createUpDownCounter(metric: MetricDefinition): UpDownCounter;
+    /**
+     * Creates a new observable up/down counter instrument.
+     * @param metric - The metric definition
+     */
+    createObservableUpDownCounter(metric: MetricDefinition): ObservableUpDownCounter;
+}
+/**
+ * A telemetry client that provides meters for recording metrics.
+ */
+export interface TelemetryClient {
+    /**
+     * Whether the client is enabled and reporting metrics.
+     **/
+    isEnabled(): boolean;
+    /**
+     * Creates a new meter
+     * @param name - The name of the meter.
+     */
+    getMeter(name: string): Meter;
+    /**
+     * Creates a new tracer
+     * @param name - The name of the tracer.
+     */
+    getTracer(name: string): Tracer;
+    /**
+     * Stops the telemetry client.
+     */
+    stop(): Promise<void>;
+    /**
+     * 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 */
+export interface Traceable {
+    tracer: Tracer;
+}
+type SpanDecorator<T extends Traceable, F extends (...args: any[]) => any> = (originalMethod: F, context: ClassMethodDecoratorContext<T>) => F;
+/**
+ * Starts a new span whenever the decorated method is called.
+ * @param spanName - The name of the span to create. Can be a string or a function that returns a string.
+ * @param attributes - Initial attributes to set on the span. If a function is provided, it will be called with the arguments of the method.
+ * @param extraAttributes - Extra attributes to set on the span after the method is called. Will be called with the return value of the method. Note: if the function throws then this will not be called.
+ * @returns A decorator that wraps the method in a span.
+ *
+ * @privateRemarks
+ * This code looks complex but it's not that difficult:
+ * - decorators are functions that _replace_ a method with a different implementation
+ * - normal decorators can't take function arguments, but if we write a function that returns a decorator, we can pass arguments to that function
+ *
+ * The trackSpan function takes a span's name and some attributes and builds a decorator that wraps a method in a span with the given name and props
+ * The decorator can currently only be applied to methods on classes that have a `tracer` property. The compiler will enforce this.
+ */
+export declare function trackSpan<T extends Traceable, F extends (...args: any[]) => any>(spanName: string | ((this: T, ...args: Parameters<F>) => string), attributes?: AttributesType | ((this: T, ...args: Parameters<F>) => Promise<AttributesType> | AttributesType), extraAttributes?: (this: T, returnValue: Awaited<ReturnType<F>>) => AttributesType): SpanDecorator<T, F>;
+/**
+ * Runs an event callback in a span. The span is started immediately and completes once the callback finishes running.
+ * The span will have two events added: 'callbackStart' and 'callbackEnd' to mark the start and end of the callback.
+ *
+ * @param tracer - The tracer instance to use
+ * @param spanName - The name of the span to create
+ * @param attributes - Initial attributes to set on the span
+ * @param callback - The callback to wrap in a span
+ *
+ * @returns - A new function that wraps the callback in a span
+ */
+export declare function wrapCallbackInSpan<F extends (...args: any[]) => any>(tracer: Tracer, spanName: string, attributes: AttributesType, callback: F): F;
+export declare function runInSpan<A extends any[], R>(tracer: Tracer | string, spanName: string, callback: (span: Span, ...args: A) => Promise<R>): (...args: A) => Promise<R>;
+/**
+ * Execute a callback within a span immediately (for one-off traced calls).
+ * Unlike runInSpan which returns a reusable function, this executes right away.
+ */
+export declare function execInSpan<R>(tracer: Tracer | string, spanName: string, callback: (span: Span) => Promise<R>): Promise<R>;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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"}

package/dest/telemetry.js

@@ -0,0 +1,139 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { getTelemetryClient } from './start.js';
+export { toMetricOptions, createUpDownCounterWithDefault } from './metric-utils.js';
+export { SpanStatusCode, ValueType } from '@opentelemetry/api';
+/**
+ * Starts a new span whenever the decorated method is called.
+ * @param spanName - The name of the span to create. Can be a string or a function that returns a string.
+ * @param attributes - Initial attributes to set on the span. If a function is provided, it will be called with the arguments of the method.
+ * @param extraAttributes - Extra attributes to set on the span after the method is called. Will be called with the return value of the method. Note: if the function throws then this will not be called.
+ * @returns A decorator that wraps the method in a span.
+ *
+ * @privateRemarks
+ * This code looks complex but it's not that difficult:
+ * - decorators are functions that _replace_ a method with a different implementation
+ * - normal decorators can't take function arguments, but if we write a function that returns a decorator, we can pass arguments to that function
+ *
+ * The trackSpan function takes a span's name and some attributes and builds a decorator that wraps a method in a span with the given name and props
+ * The decorator can currently only be applied to methods on classes that have a `tracer` property. The compiler will enforce this.
+ */ export function trackSpan(spanName, attributes, extraAttributes) {
+    // the return value of trackSpan is a decorator
+    return (originalMethod, _context)=>{
+        // the return value of the decorator replaces the original method
+        // in this wrapper method we start a span, call the original method, and then end the span
+        return async function replacementMethod(...args) {
+            const name = typeof spanName === 'function' ? spanName.call(this, ...args) : spanName;
+            const currentAttrs = typeof attributes === 'function' ? await attributes.call(this, ...args) : attributes;
+            // 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-v22.x/docs/api/async_context.html
+            return this.tracer.startActiveSpan(name, {
+                attributes: currentAttrs
+            }, async (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();
+                }
+            });
+        };
+    };
+}
+/**
+ * Runs an event callback in a span. The span is started immediately and completes once the callback finishes running.
+ * The span will have two events added: 'callbackStart' and 'callbackEnd' to mark the start and end of the callback.
+ *
+ * @param tracer - The tracer instance to use
+ * @param spanName - The name of the span to create
+ * @param attributes - Initial attributes to set on the span
+ * @param callback - The callback to wrap in a span
+ *
+ * @returns - A new function that wraps the callback in a span
+ */ export function wrapCallbackInSpan(tracer, spanName, attributes, callback) {
+    const span = tracer.startSpan(spanName, {
+        attributes
+    });
+    return async (...args)=>{
+        try {
+            span.addEvent('callbackStart');
+            const res = await callback(...args);
+            return res;
+        } catch (err) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: String(err)
+            });
+            throw err;
+        } finally{
+            span.addEvent('callbackEnd');
+            span.end();
+        }
+    };
+}
+export function runInSpan(tracer, spanName, callback) {
+    return (...args)=>{
+        const actualTracer = typeof tracer === 'string' ? getTelemetryClient().getTracer(tracer) : tracer;
+        return actualTracer.startActiveSpan(spanName, async (span)=>{
+            try {
+                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{
+                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(tracer, spanName, callback) {
+    const actualTracer = typeof tracer === 'string' ? getTelemetryClient().getTracer(tracer) : tracer;
+    return actualTracer.startActiveSpan(spanName, async (span)=>{
+        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/dest/vendor/attributes.d.ts

@@ -0,0 +1,6 @@
+export declare const ATTR_JSONRPC_METHOD = "rpc.method";
+export declare const ATTR_JSONRPC_SERVICE = "rpc.service";
+export declare const ATTR_JSONRPC_REQUEST_ID = "rpc.jsonrpc.request_id";
+export declare const ATTR_JSONRPC_ERROR_CODE = "rpc.jsonrpc.error_code";
+export declare const ATTR_JSONRPC_ERROR_MSG = "rpc.jsonrpc.error_message";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0cmlidXRlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ZlbmRvci9hdHRyaWJ1dGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLGVBQU8sTUFBTSxtQkFBbUIsZUFBZSxDQUFDO0FBQ2hELGVBQU8sTUFBTSxvQkFBb0IsZ0JBQWdCLENBQUM7QUFDbEQsZUFBTyxNQUFNLHVCQUF1QiwyQkFBMkIsQ0FBQztBQUNoRSxlQUFPLE1BQU0sdUJBQXVCLDJCQUEyQixDQUFDO0FBQ2hFLGVBQU8sTUFBTSxzQkFBc0IsOEJBQThCLENBQUMifQ==

package/dest/vendor/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../src/vendor/attributes.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAChD,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAClD,eAAO,MAAM,uBAAuB,2BAA2B,CAAC;AAChE,eAAO,MAAM,uBAAuB,2BAA2B,CAAC;AAChE,eAAO,MAAM,sBAAsB,8BAA8B,CAAC"}

package/dest/vendor/attributes.js

@@ -0,0 +1,6 @@
+// See https://opentelemetry.io/docs/specs/semconv/rpc/json-rpc/
+export const ATTR_JSONRPC_METHOD = 'rpc.method';
+export const ATTR_JSONRPC_SERVICE = 'rpc.service';
+export const ATTR_JSONRPC_REQUEST_ID = 'rpc.jsonrpc.request_id';
+export const ATTR_JSONRPC_ERROR_CODE = 'rpc.jsonrpc.error_code';
+export const ATTR_JSONRPC_ERROR_MSG = 'rpc.jsonrpc.error_message';

package/dest/vendor/otel-pino-stream.d.ts

@@ -0,0 +1,40 @@
+import { Writable } from 'stream';
+/**
+ * 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 declare function getTimeConverter(pinoLogger: any, pinoMod: any): ((time: number) => number) | ((time: string) => number);
+interface OTelPinoStreamOptions {
+    messageKey?: string;
+    levels: any;
+    otelTimestampFromTime?: (time: any) => number;
+}
+/**
+ * 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 declare class OTelPinoStream extends Writable {
+    private _otelLogger;
+    private _messageKey;
+    private _levels;
+    private _otelTimestampFromTime;
+    constructor(options: OTelPinoStreamOptions);
+    _write(s: string, _encoding: string, callback: Function): void;
+}
+export default function (options: OTelPinoStreamOptions): OTelPinoStream;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3RlbC1waW5vLXN0cmVhbS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3ZlbmRvci9vdGVsLXBpbm8tc3RyZWFtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQW9CQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBMkVsQzs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFDSCx3QkFBZ0IsZ0JBQWdCLENBQUMsVUFBVSxFQUFFLEdBQUcsRUFBRSxPQUFPLEVBQUUsR0FBRywyREFlN0Q7QUFFRCxVQUFVLHFCQUFxQjtJQUM3QixVQUFVLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDcEIsTUFBTSxFQUFFLEdBQUcsQ0FBQztJQUNaLHFCQUFxQixDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsR0FBRyxLQUFLLE1BQU0sQ0FBQztDQUMvQztBQUVEOzs7OztHQUtHO0FBQ0gscUJBQWEsY0FBZSxTQUFRLFFBQVE7SUFDMUMsT0FBTyxDQUFDLFdBQVcsQ0FBUztJQUM1QixPQUFPLENBQUMsV0FBVyxDQUFTO0lBQzVCLE9BQU8sQ0FBQyxPQUFPLENBQUM7SUFDaEIsT0FBTyxDQUFDLHNCQUFzQixDQUFDO0lBRS9CLFlBQVksT0FBTyxFQUFFLHFCQUFxQixFQWlCekM7SUFFUSxNQUFNLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxRQUFRLFFBb0cvRDtDQUNGO0FBTUQsTUFBTSxDQUFDLE9BQU8sV0FBVyxPQUFPLEVBQUUscUJBQXFCLEdBQUcsY0FBYyxDQU12RSJ9

package/dest/vendor/otel-pino-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-pino-stream.d.ts","sourceRoot":"","sources":["../../src/vendor/otel-pino-stream.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AA2ElC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,2DAe7D;AAED,UAAU,qBAAqB;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,GAAG,CAAC;IACZ,qBAAqB,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,MAAM,CAAC;CAC/C;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,QAAQ;IAC1C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,OAAO,CAAC;IAChB,OAAO,CAAC,sBAAsB,CAAC;IAE/B,YAAY,OAAO,EAAE,qBAAqB,EAiBzC;IAEQ,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,QAoG/D;CACF;AAMD,MAAM,CAAC,OAAO,WAAW,OAAO,EAAE,qBAAqB,GAAG,cAAc,CAMvE"}

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';
+// 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-labs/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-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;
+            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);
+}