@eventuras/logger 0.7.0

package/dist/opentelemetry.d.ts

@@ -0,0 +1,136 @@
+/**
+ * OpenTelemetry integration for @eventuras/logger
+ *
+ * This module provides integration between Pino and OpenTelemetry Logs API.
+ * It allows sending logs to any OpenTelemetry-compatible backend (Sentry, Grafana, Jaeger, etc.)
+ * without vendor lock-in.
+ *
+ * NOTE: This module requires OpenTelemetry packages to be installed as peer dependencies.
+ * If they are not available, the integration will gracefully disable itself.
+ *
+ * @example
+ * // In your app's instrumentation.ts or main entry point
+ * import { setupOpenTelemetryLogger } from '@eventuras/logger/opentelemetry';
+ * import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+ * import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+ *
+ * setupOpenTelemetryLogger({
+ *   logRecordProcessor: new BatchLogRecordProcessor(
+ *     new OTLPLogExporter({
+ *       url: 'https://[org].ingest.sentry.io/api/[project]/integration/otlp/v1/logs',
+ *       headers: { 'x-sentry-auth': 'sentry sentry_key=...' }
+ *     })
+ *   )
+ * });
+ *
+ * @example
+ * // Then use logger as normal
+ * import { Logger } from '@eventuras/logger';
+ *
+ * const logger = Logger.create({ namespace: 'MyService' });
+ * logger.error({ error: err }, 'Something failed'); // Sent to OpenTelemetry backend
+ */
+/**
+ * Minimal interface for an OpenTelemetry LogRecordProcessor.
+ * Compatible with `@opentelemetry/sdk-logs` `LogRecordProcessor`.
+ * Defined locally to avoid requiring OTel types at compile time.
+ */
+export interface LogRecordProcessor {
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}
+/**
+ * Minimal interface for an OpenTelemetry LoggerProvider.
+ * Compatible with `@opentelemetry/sdk-logs` `LoggerProvider`.
+ */
+export interface OTelLoggerProvider {
+    addLogRecordProcessor(processor: LogRecordProcessor): void;
+    shutdown(): Promise<void>;
+    forceFlush?(): Promise<void>;
+}
+/**
+ * Options for OpenTelemetry logger integration
+ */
+export type OpenTelemetryLoggerOptions = {
+    /**
+     * Log record processor (e.g., BatchLogRecordProcessor with an exporter).
+     * If not provided, logs will only be instrumented but not exported.
+     */
+    logRecordProcessor?: LogRecordProcessor;
+    /**
+     * Logger provider instance. If not provided, a new one will be created.
+     */
+    loggerProvider?: OTelLoggerProvider;
+    /**
+     * Service name to attach to log records.
+     * Defaults to the `OTEL_SERVICE_NAME` environment variable, or `'unknown-service'`.
+     */
+    serviceName?: string;
+    /**
+     * Whether to enable the integration. Default: true
+     */
+    enabled?: boolean;
+};
+/**
+ * Set up OpenTelemetry integration for Pino logger.
+ *
+ * This function:
+ * 1. Creates or uses provided LoggerProvider
+ * 2. Registers the log record processor (for exporting logs)
+ * 3. Enables Pino instrumentation to bridge Pino logs to OTel
+ *
+ * Call this function once at application startup, before creating any loggers.
+ *
+ * @param options - Configuration options
+ *
+ * @example
+ * // Send to Sentry via OTLP
+ * import { setupOpenTelemetryLogger } from '@eventuras/logger';
+ * import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+ * import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+ *
+ * setupOpenTelemetryLogger({
+ *   logRecordProcessor: new BatchLogRecordProcessor(
+ *     new OTLPLogExporter({
+ *       url: process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+ *       headers: {
+ *         'x-sentry-auth': `sentry sentry_key=${process.env.SENTRY_KEY}`
+ *       }
+ *     })
+ *   )
+ * });
+ *
+ * @example
+ * // Use environment variables (recommended)
+ * // Set these in your environment:
+ * // OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://[org].ingest.sentry.io/api/[project]/integration/otlp/v1/logs
+ * // OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-sentry-auth=sentry sentry_key=...
+ *
+ * import { setupOpenTelemetryLogger } from '@eventuras/logger';
+ * import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+ * import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+ *
+ * await setupOpenTelemetryLogger({
+ *   logRecordProcessor: new BatchLogRecordProcessor(
+ *     new OTLPLogExporter() // Reads from env vars
+ *   )
+ * });
+ */
+export declare function setupOpenTelemetryLogger(options?: OpenTelemetryLoggerOptions): Promise<void>;
+/**
+ * Shut down the OpenTelemetry logger integration.
+ * Call this when your application is shutting down to flush any pending logs.
+ *
+ * @example
+ * process.on('SIGTERM', async () => {
+ *   await shutdownOpenTelemetryLogger();
+ *   process.exit(0);
+ * });
+ */
+export declare function shutdownOpenTelemetryLogger(): Promise<void>;
+/**
+ * Get the active LoggerProvider instance, if any.
+ * Useful for advanced use cases or debugging.
+ */
+export declare function getLoggerProvider(): OTelLoggerProvider | null;
+//# sourceMappingURL=opentelemetry.d.ts.map

package/dist/opentelemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.d.ts","sourceRoot":"","sources":["../src/opentelemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,qBAAqB,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC3D,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAwBD;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IAExC;;OAEG;IACH,cAAc,CAAC,EAAE,kBAAkB,CAAC;IAEpC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,IAAI,CAAC,CA+Df;AAED;;;;;;;;;GASG;AACH,wBAAsB,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBjE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,kBAAkB,GAAG,IAAI,CAO7D"}

package/dist/opentelemetry.js

@@ -0,0 +1,44 @@
+import { a as e } from "./chunk-NnHqS4_Y.js";
+//#region src/opentelemetry.ts
+async function t() {
+	try {
+		let [t, n] = await Promise.all([import("./src-V4zpQbfq.js").then((t) => /* @__PURE__ */ e(t.default, 1)), import("./esm-wJpbN37y.js")]);
+		return {
+			PinoInstrumentation: t.PinoInstrumentation,
+			LoggerProvider: n.LoggerProvider
+		};
+	} catch {
+		return null;
+	}
+}
+var n = null, r = null;
+async function i(e = {}) {
+	if (typeof window < "u") {
+		console.warn("[logger] OpenTelemetry integration is server-side only - skipping in browser");
+		return;
+	}
+	let { logRecordProcessor: i, loggerProvider: a, serviceName: o, enabled: s = !0 } = e;
+	if (!s) {
+		console.log("[logger] OpenTelemetry integration disabled");
+		return;
+	}
+	let c = await t();
+	if (!c) {
+		console.warn("[logger] OpenTelemetry packages not available - integration disabled"), console.warn("[logger] Install @opentelemetry/* packages to enable OpenTelemetry integration");
+		return;
+	}
+	let { PinoInstrumentation: l, LoggerProvider: u } = c;
+	n &&= (n.disable(), null), r = a ?? new u(), i && r && r.addLogRecordProcessor(i);
+	let d = o ?? (typeof process < "u" ? process.env?.OTEL_SERVICE_NAME : void 0) ?? "unknown-service";
+	n = new l({ logHook: (e, t) => {
+		t["service.name"] = d;
+	} }), n.enable(), console.log("[logger] OpenTelemetry integration enabled"), i && console.log("[logger] Log record processor registered");
+}
+async function a() {
+	typeof window < "u" || (n &&= (n.disable(), null), r &&= (await r.shutdown(), null), console.log("[logger] OpenTelemetry integration shut down"));
+}
+function o() {
+	return typeof window < "u" ? null : r;
+}
+//#endregion
+export { o as getLoggerProvider, i as setupOpenTelemetryLogger, a as shutdownOpenTelemetryLogger };

package/dist/pretty-BTJ0fKhV.js

@@ -0,0 +1,114 @@
+import { t as e } from "./__vite-browser-external-pQ4XsTOI.js";
+//#region src/transports/pretty.ts
+var t = e(), n = {
+	reset: "\x1B[0m",
+	dim: "\x1B[2m",
+	bold: "\x1B[1m",
+	red: "\x1B[31m",
+	yellow: "\x1B[33m",
+	green: "\x1B[32m",
+	cyan: "\x1B[36m",
+	magenta: "\x1B[35m",
+	gray: "\x1B[90m"
+}, r = {
+	10: {
+		label: "TRACE",
+		color: n.gray
+	},
+	20: {
+		label: "DEBUG",
+		color: n.cyan
+	},
+	30: {
+		label: "INFO ",
+		color: n.green
+	},
+	40: {
+		label: "WARN ",
+		color: n.yellow
+	},
+	50: {
+		label: "ERROR",
+		color: n.red
+	},
+	60: {
+		label: "FATAL",
+		color: `${n.bold}${n.red}`
+	}
+}, i = {
+	trace: {
+		label: "TRACE",
+		color: n.gray
+	},
+	debug: {
+		label: "DEBUG",
+		color: n.cyan
+	},
+	info: {
+		label: "INFO ",
+		color: n.green
+	},
+	warn: {
+		label: "WARN ",
+		color: n.yellow
+	},
+	error: {
+		label: "ERROR",
+		color: n.red
+	},
+	fatal: {
+		label: "FATAL",
+		color: `${n.bold}${n.red}`
+	}
+}, a = new Set([
+	"level",
+	"time",
+	"pid",
+	"hostname",
+	"msg",
+	"name",
+	"ns",
+	"namespace"
+]);
+function o(e) {
+	if (typeof e == "string") {
+		let t = new Date(e);
+		return Number.isNaN(t.getTime()) ? "" : t.toLocaleTimeString("en-GB", { hour12: !1 });
+	}
+	return typeof e == "number" ? new Date(e).toLocaleTimeString("en-GB", { hour12: !1 }) : (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: !1 });
+}
+function s(e) {
+	let t = {}, r = !1;
+	for (let [n, i] of Object.entries(e)) a.has(n) || (t[n] = i, r = !0);
+	return r ? ` ${n.dim}${JSON.stringify(t)}${n.reset}` : "";
+}
+function c(e) {
+	let t = e.trim();
+	if (!t) return "";
+	let a;
+	try {
+		a = JSON.parse(t);
+	} catch {
+		return t;
+	}
+	let c = a.level, l = typeof c == "string" ? i[c] ?? {
+		label: c.toUpperCase().padEnd(5),
+		color: n.gray
+	} : r[c] ?? {
+		label: `L${c}`,
+		color: n.gray
+	}, u = o(a.time), d = a.msg ?? "", f = a.namespace || a.ns || a.name || "", p = f ? ` ${n.magenta}(${f})${n.reset}` : "", m = `${n.dim}→${n.reset}`, h = s(a);
+	return `${n.dim}${u}${n.reset} ${l.color}${l.label}${n.reset}${p} ${m} ${d}${h}`;
+}
+function l() {
+	return new t.Writable({ write(e, t, n) {
+		let r = e.toString().split("\n");
+		for (let e of r) {
+			let t = c(e);
+			t && process.stdout.write(t + "\n");
+		}
+		n();
+	} });
+}
+//#endregion
+export { c as n, l as t };

package/dist/src-V4zpQbfq.js

@@ -0,0 +1,406 @@
+import { i as e, n as t, r as n, t as r } from "./chunk-NnHqS4_Y.js";
+import { t as i } from "./__vite-browser-external-pQ4XsTOI.js";
+import { D as a, E as o, O as s, T as c, b as l, n as u, t as d, w as f, x as p, y as m } from "./esm-B1-Y8LUx.js";
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/instrumentation/build/esm/autoLoaderUtils.js
+function h(e, t, n, r) {
+	for (let i = 0, a = e.length; i < a; i++) {
+		let a = e[i];
+		t && a.setTracerProvider(t), n && a.setMeterProvider(n), r && a.setLoggerProvider && a.setLoggerProvider(r), a.getConfig().enabled || a.enable();
+	}
+}
+function g(e) {
+	e.forEach((e) => e.disable());
+}
+var _ = t((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/instrumentation/build/esm/autoLoader.js
+function v(e) {
+	let t = e.tracerProvider || o.getTracerProvider(), n = e.meterProvider || a.getMeterProvider(), r = e.loggerProvider || p.getLoggerProvider(), i = e.instrumentations?.flat() ?? [];
+	return h(i, t, n, r), () => {
+		g(i);
+	};
+}
+var y = t((() => {
+	c(), l(), _();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/instrumentation/build/esm/shimmer.js
+function b(e, t, n) {
+	let r = !!e[t] && Object.prototype.propertyIsEnumerable.call(e, t);
+	Object.defineProperty(e, t, {
+		configurable: !0,
+		enumerable: r,
+		writable: !0,
+		value: n
+	});
+}
+function x(e) {
+	e && e.logger && (typeof e.logger == "function" ? S = e.logger : S("new logger isn't a function, not replacing"));
+}
+var S, C, w, T, E, D = t((() => {
+	S = console.error.bind(console), C = (e, t, n) => {
+		if (!e || !e[t]) {
+			S("no original function " + String(t) + " to wrap");
+			return;
+		}
+		if (!n) {
+			S("no wrapper function"), S((/* @__PURE__ */ Error()).stack);
+			return;
+		}
+		let r = e[t];
+		if (typeof r != "function" || typeof n != "function") {
+			S("original object and wrapper must be functions");
+			return;
+		}
+		let i = n(r, t);
+		return b(i, "__original", r), b(i, "__unwrap", () => {
+			e[t] === i && b(e, t, r);
+		}), b(i, "__wrapped", !0), b(e, t, i), i;
+	}, w = (e, t, n) => {
+		if (e) Array.isArray(e) || (e = [e]);
+		else {
+			S("must provide one or more modules to patch"), S((/* @__PURE__ */ Error()).stack);
+			return;
+		}
+		if (!(t && Array.isArray(t))) {
+			S("must provide one or more functions to wrap on modules");
+			return;
+		}
+		e.forEach((e) => {
+			t.forEach((t) => {
+				C(e, t, n);
+			});
+		});
+	}, T = (e, t) => {
+		if (!e || !e[t]) {
+			S("no function to unwrap."), S((/* @__PURE__ */ Error()).stack);
+			return;
+		}
+		let n = e[t];
+		if (!n.__unwrap) S("no original to unwrap to -- has " + String(t) + " already been unwrapped?");
+		else {
+			n.__unwrap();
+			return;
+		}
+	}, E = (e, t) => {
+		if (e) Array.isArray(e) || (e = [e]);
+		else {
+			S("must provide one or more modules to patch"), S((/* @__PURE__ */ Error()).stack);
+			return;
+		}
+		if (!(t && Array.isArray(t))) {
+			S("must provide one or more functions to unwrap on modules");
+			return;
+		}
+		e.forEach((e) => {
+			t.forEach((t) => {
+				T(e, t);
+			});
+		});
+	}, x.wrap = C, x.massWrap = w, x.unwrap = T, x.massUnwrap = E;
+})), O, k = t((() => {
+	c(), l(), D(), O = class {
+		_config = {};
+		_tracer;
+		_meter;
+		_logger;
+		_diag;
+		instrumentationName;
+		instrumentationVersion;
+		constructor(e, t, n) {
+			this.instrumentationName = e, this.instrumentationVersion = t, this.setConfig(n), this._diag = s.createComponentLogger({ namespace: e }), this._tracer = o.getTracer(e, t), this._meter = a.getMeter(e, t), this._logger = p.getLogger(e, t), this._updateMetricInstruments();
+		}
+		_wrap = C;
+		_unwrap = T;
+		_massWrap = w;
+		_massUnwrap = E;
+		get meter() {
+			return this._meter;
+		}
+		setMeterProvider(e) {
+			this._meter = e.getMeter(this.instrumentationName, this.instrumentationVersion), this._updateMetricInstruments();
+		}
+		get logger() {
+			return this._logger;
+		}
+		setLoggerProvider(e) {
+			this._logger = e.getLogger(this.instrumentationName, this.instrumentationVersion);
+		}
+		getModuleDefinitions() {
+			let e = this.init() ?? [];
+			return Array.isArray(e) ? e : [e];
+		}
+		_updateMetricInstruments() {}
+		getConfig() {
+			return this._config;
+		}
+		setConfig(e) {
+			this._config = {
+				enabled: !0,
+				...e
+			};
+		}
+		setTracerProvider(e) {
+			this._tracer = e.getTracer(this.instrumentationName, this.instrumentationVersion);
+		}
+		get tracer() {
+			return this._tracer;
+		}
+		_runSpanCustomizationHook(e, t, n, r) {
+			if (e) try {
+				e(n, r);
+			} catch (e) {
+				this._diag.error("Error running span customization hook due to exception in handler", { triggerName: t }, e);
+			}
+		}
+	};
+})), A, j = t((() => {
+	k(), A = class extends O {
+		constructor(e, t, n) {
+			super(e, t, n), this._config.enabled && this.enable();
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/instrumentation/build/esm/platform/browser/noop-normalize.js
+function M(e) {
+	return s.warn("Path normalization is not implemented for this platform. To silence this warning, ensure no node-specific instrumentations are loaded, and node-specific types (e.g. InstrumentationNodeModuleFile), are not used in a browser context)"), e;
+}
+var N = t((() => {
+	c();
+})), P = t((() => {
+	j(), N();
+})), F, I = t((() => {
+	F = class {
+		files;
+		name;
+		supportedVersions;
+		patch;
+		unpatch;
+		constructor(e, t, n, r, i) {
+			this.files = i || [], this.name = e, this.supportedVersions = t, this.patch = n, this.unpatch = r;
+		}
+	};
+})), L, R = t((() => {
+	P(), L = class {
+		name;
+		supportedVersions;
+		patch;
+		unpatch;
+		constructor(e, t, n, r) {
+			this.name = M(e), this.supportedVersions = t, this.patch = n, this.unpatch = r;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/instrumentation/build/esm/utils.js
+function z(e, t, n) {
+	let r, i;
+	try {
+		i = e();
+	} catch (e) {
+		r = e;
+	} finally {
+		if (t(r, i), r && !n) throw r;
+		return i;
+	}
+}
+async function B(e, t, n) {
+	let r, i;
+	try {
+		i = await e();
+	} catch (e) {
+		r = e;
+	} finally {
+		if (await t(r, i), r && !n) throw r;
+		return i;
+	}
+}
+function V(e) {
+	return typeof e == "function" && typeof e.__original == "function" && typeof e.__unwrap == "function" && e.__wrapped === !0;
+}
+var H = t((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.214.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/instrumentation/build/esm/semconvStability.js
+function U(e, t) {
+	let n = W.OLD, r = t?.split(",").map((e) => e.trim()).filter((e) => e !== "");
+	for (let t of r ?? []) if (t.toLowerCase() === e + "/dup") {
+		n = W.DUPLICATE;
+		break;
+	} else t.toLowerCase() === e && (n = W.STABLE);
+	return n;
+}
+var W, G = t((() => {
+	(function(e) {
+		e[e.STABLE = 1] = "STABLE", e[e.OLD = 2] = "OLD", e[e.DUPLICATE = 3] = "DUPLICATE";
+	})(W ||= {});
+})), K = /* @__PURE__ */ n({
+	InstrumentationBase: () => A,
+	InstrumentationNodeModuleDefinition: () => F,
+	InstrumentationNodeModuleFile: () => L,
+	SemconvStability: () => W,
+	isWrapped: () => V,
+	registerInstrumentations: () => v,
+	safeExecuteInTheMiddle: () => z,
+	safeExecuteInTheMiddleAsync: () => B,
+	semconvStabilityFromStr: () => U
+}), q = t((() => {
+	y(), P(), I(), R(), H(), G();
+})), J = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.PACKAGE_NAME = e.PACKAGE_VERSION = void 0, e.PACKAGE_VERSION = "0.60.0", e.PACKAGE_NAME = "@opentelemetry/instrumentation-pino";
+})), Y = /* @__PURE__ */ r(((t) => {
+	Object.defineProperty(t, "__esModule", { value: !0 }), t.OTelPinoStream = t.getTimeConverter = void 0;
+	var n = i(), r = (l(), e(m)), a = J(), o = (u(), e(d)), s = {
+		trace: 10,
+		debug: 20,
+		info: 30,
+		warn: 40,
+		error: 50,
+		fatal: 60
+	}, c = {
+		[s.trace]: r.SeverityNumber.TRACE,
+		[s.debug]: r.SeverityNumber.DEBUG,
+		[s.info]: r.SeverityNumber.INFO,
+		[s.warn]: r.SeverityNumber.WARN,
+		[s.error]: r.SeverityNumber.ERROR,
+		[s.fatal]: r.SeverityNumber.FATAL
+	}, f = [
+		r.SeverityNumber.TRACE2,
+		r.SeverityNumber.TRACE3,
+		r.SeverityNumber.TRACE4,
+		r.SeverityNumber.DEBUG2,
+		r.SeverityNumber.DEBUG3,
+		r.SeverityNumber.DEBUG4,
+		r.SeverityNumber.INFO2,
+		r.SeverityNumber.INFO3,
+		r.SeverityNumber.INFO4,
+		r.SeverityNumber.WARN2,
+		r.SeverityNumber.WARN3,
+		r.SeverityNumber.WARN4,
+		r.SeverityNumber.ERROR2,
+		r.SeverityNumber.ERROR3,
+		r.SeverityNumber.ERROR4,
+		r.SeverityNumber.FATAL2,
+		r.SeverityNumber.FATAL3,
+		r.SeverityNumber.FATAL4
+	];
+	function p(e) {
+		let t = c[e];
+		if (t !== void 0) return t;
+		let n = (e - 10) / 60, r = Math.floor(n * f.length);
+		return f[Math.min(f.length - 1, Math.max(0, r))];
+	}
+	function h(e, t) {
+		let n = t.stdTimeFunctions, r = e[t.symbols.timeSym];
+		return r === n.epochTime ? (e) => e : r === n.unixTime ? (e) => e * 1e3 : r === n.isoTime ? (e) => new Date(e).getTime() : r === n.nullTime ? () => Date.now() : () => NaN;
+	}
+	t.getTimeConverter = h, t.OTelPinoStream = class extends n.Writable {
+		constructor(e) {
+			super(), this._messageKey = e.messageKey, this._levels = e.levels, this._otelTimestampFromTime = e.otelTimestampFromTime, this._otelLogger = r.logs.getLogger(a.PACKAGE_NAME, a.PACKAGE_VERSION);
+		}
+		_write(e, t, n) {
+			/* istanbul ignore if */
+			if (!e) return;
+			let r;
+			try {
+				r = JSON.parse(e);
+			} catch (t) {
+				this.emit("unknown", e.toString(), t), n();
+				return;
+			}
+			/* istanbul ignore if */
+			if (r === null) {
+				this.emit("unknown", e.toString(), "Null value ignored"), n();
+				return;
+			}
+			/* istanbul ignore if */
+			typeof r != "object" && (r = { data: r });
+			let { time: i, [this._messageKey]: a, level: s, hostname: c, pid: l, trace_id: u, span_id: d, trace_flags: f, ...m } = r, h = this._otelTimestampFromTime(i);
+			isNaN(h) && (m.time = i, h = Date.now());
+			let g = (0, o.millisToHrTime)(h), _ = this.lastLevel, v = {
+				timestamp: g,
+				observedTimestamp: g,
+				severityNumber: p(_),
+				severityText: this._levels.labels[_],
+				body: a,
+				attributes: m
+			};
+			this._otelLogger.emit(v), n();
+		}
+	};
+})), X = /* @__PURE__ */ r(((t) => {
+	Object.defineProperty(t, "__esModule", { value: !0 }), t.PinoInstrumentation = void 0;
+	var n = (c(), e(f)), r = (q(), e(K)), i = J(), a = Y(), o = [">=5.14.0 <11"], s = {
+		traceId: "trace_id",
+		spanId: "span_id",
+		traceFlags: "trace_flags"
+	};
+	t.PinoInstrumentation = class extends r.InstrumentationBase {
+		constructor(e = {}) {
+			super(i.PACKAGE_NAME, i.PACKAGE_VERSION, e);
+		}
+		init() {
+			return [new r.InstrumentationNodeModuleDefinition("pino", o, (e) => {
+				let t = e[Symbol.toStringTag] === "Module", n = t ? e.default : e, r = this, i = Object.assign((...e) => {
+					let t = r.getConfig(), i = r.isEnabled(), o = n(...e), s = r._getMixinFunction(), c = n.symbols.mixinSym, l = o[c];
+					if (l === void 0 ? o[c] = s : o[c] = (e, t, ...n) => Object.assign(s(e, t), l(e, t, ...n)), i && !t.disableLogSending && typeof n.multistream == "function") {
+						let e = (0, a.getTimeConverter)(o, n), t = new a.OTelPinoStream({
+							messageKey: o[n.symbols.messageKeySym],
+							levels: o.levels,
+							otelTimestampFromTime: e
+						});
+						t[Symbol.for("pino.metadata")] = !0, t.once("unknown", (e, t) => {
+							r._diag.warn("could not send pino log line (will only log first occurrence)", {
+								line: e,
+								err: t
+							});
+						});
+						let i = o[n.symbols.streamSym];
+						o[n.symbols.streamSym] = n.multistream([{
+							level: 0,
+							stream: i
+						}, {
+							level: 0,
+							stream: t
+						}], { levels: o.levels.values });
+					}
+					return o;
+				}, n);
+				return typeof i.pino == "function" && (i.pino = i), typeof i.default == "function" && (i.default = i), t && (e.pino &&= i, e.default = i), i;
+			})];
+		}
+		_callHook(e, t, i) {
+			let { logHook: a } = this.getConfig();
+			a && (0, r.safeExecuteInTheMiddle)(() => a(e, t, i), (e) => {
+				e && n.diag.error("pino instrumentation: error calling logHook", e);
+			}, !0);
+		}
+		_getMixinFunction() {
+			let e = this;
+			return function(t, r) {
+				if (!e.isEnabled() || e.getConfig().disableLogCorrelation) return {};
+				let i = n.trace.getSpan(n.context.active());
+				if (!i) return {};
+				let a = i.spanContext();
+				if (!(0, n.isSpanContextValid)(a)) return {};
+				let o = e.getConfig().logKeys ?? s, c = {
+					[o.traceId]: a.traceId,
+					[o.spanId]: a.spanId,
+					[o.traceFlags]: `0${a.traceFlags.toString(16)}`
+				};
+				return e._callHook(i, c, r), c;
+			};
+		}
+	};
+})), Z = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.PinoInstrumentation = void 0;
+	var t = X();
+	Object.defineProperty(e, "PinoInstrumentation", {
+		enumerable: !0,
+		get: function() {
+			return t.PinoInstrumentation;
+		}
+	});
+}));
+//#endregion
+export default Z();