@eventuras/logger 0.8.0 → 0.8.1

package/dist/node.js

@@ -1,7 +1,15 @@
-import { r as e, t } from "./Logger-CcNEmm6u.js";
-import { Writable as n } from "node:stream";
+import { r as PinoTransport, t as Logger } from "./Logger-n-HsscG5.js";
+import { Writable } from "node:stream";
 //#region src/transports/pretty.ts
-var r = {
+/**
+* Lightweight pretty-print formatter for development.
+* Zero external dependencies — uses ANSI colors and simple formatting.
+*
+* Produces output like:
+*   12:34:56 INFO  (web:auth) → User logged in
+*   12:34:56 ERROR (web:auth) → Failed to authenticate { error: "invalid token" }
+*/
+var ANSI = {
 	reset: "\x1B[0m",
 	dim: "\x1B[2m",
 	bold: "\x1B[1m",
@@ -11,57 +19,61 @@ var r = {
 	cyan: "\x1B[36m",
 	magenta: "\x1B[35m",
 	gray: "\x1B[90m"
-}, i = {
+};
+var LEVEL_BY_NUMBER = {
 	10: {
 		label: "TRACE",
-		color: r.gray
+		color: ANSI.gray
 	},
 	20: {
 		label: "DEBUG",
-		color: r.cyan
+		color: ANSI.cyan
 	},
 	30: {
 		label: "INFO ",
-		color: r.green
+		color: ANSI.green
 	},
 	40: {
 		label: "WARN ",
-		color: r.yellow
+		color: ANSI.yellow
 	},
 	50: {
 		label: "ERROR",
-		color: r.red
+		color: ANSI.red
 	},
 	60: {
 		label: "FATAL",
-		color: `${r.bold}${r.red}`
+		color: `${ANSI.bold}${ANSI.red}`
 	}
-}, a = {
+};
+var LEVEL_BY_NAME = {
 	trace: {
 		label: "TRACE",
-		color: r.gray
+		color: ANSI.gray
 	},
 	debug: {
 		label: "DEBUG",
-		color: r.cyan
+		color: ANSI.cyan
 	},
 	info: {
 		label: "INFO ",
-		color: r.green
+		color: ANSI.green
 	},
 	warn: {
 		label: "WARN ",
-		color: r.yellow
+		color: ANSI.yellow
 	},
 	error: {
 		label: "ERROR",
-		color: r.red
+		color: ANSI.red
 	},
 	fatal: {
 		label: "FATAL",
-		color: `${r.bold}${r.red}`
+		color: `${ANSI.bold}${ANSI.red}`
 	}
-}, o = new Set([
+};
+/** Keys excluded from the "extra data" output. */
+var INTERNAL_KEYS = new Set([
 	"level",
 	"time",
 	"pid",
@@ -71,60 +83,114 @@ var r = {
 	"ns",
 	"namespace"
 ]);
-function s(e) {
-	if (typeof e == "string") {
-		let t = new Date(e);
-		return Number.isNaN(t.getTime()) ? "" : t.toLocaleTimeString("en-GB", { hour12: !1 });
+function formatTime(time) {
+	if (typeof time === "string") {
+		const d = new Date(time);
+		return Number.isNaN(d.getTime()) ? "" : d.toLocaleTimeString("en-GB", { hour12: false });
 	}
-	return typeof e == "number" ? new Date(e).toLocaleTimeString("en-GB", { hour12: !1 }) : (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: !1 });
+	if (typeof time === "number") return new Date(time).toLocaleTimeString("en-GB", { hour12: false });
+	return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB", { hour12: false });
 }
-function c(e) {
-	let t = {}, n = !1;
-	for (let [r, i] of Object.entries(e)) o.has(r) || (t[r] = i, n = !0);
-	return n ? ` ${r.dim}${JSON.stringify(t)}${r.reset}` : "";
+function formatData(obj) {
+	const filtered = {};
+	let hasKeys = false;
+	for (const [key, value] of Object.entries(obj)) if (!INTERNAL_KEYS.has(key)) {
+		filtered[key] = value;
+		hasKeys = true;
+	}
+	if (!hasKeys) return "";
+	return ` ${ANSI.dim}${JSON.stringify(filtered)}${ANSI.reset}`;
 }
-function l(e) {
-	let t = e.trim();
-	if (!t) return "";
-	let n;
+/**
+* Format a Pino JSON log line into a human-readable string.
+* @param line Raw JSON string from Pino
+* @returns Formatted string, or the original line if parsing fails
+*/
+function formatLogLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed) return "";
+	let obj;
 	try {
-		n = JSON.parse(t);
+		obj = JSON.parse(trimmed);
 	} catch {
-		return t;
+		return trimmed;
 	}
-	let o = n.level, l = typeof o == "string" ? a[o] ?? {
-		label: o.toUpperCase().padEnd(5),
-		color: r.gray
-	} : i[o] ?? {
-		label: `L${o}`,
-		color: r.gray
-	}, u = s(n.time), d = n.msg ?? "", f = n.namespace || n.ns || n.name || "", p = f ? ` ${r.magenta}(${f})${r.reset}` : "", m = `${r.dim}→${r.reset}`, h = c(n);
-	return `${r.dim}${u}${r.reset} ${l.color}${l.label}${r.reset}${p} ${m} ${d}${h}`;
+	const level = obj.level;
+	const config = typeof level === "string" ? LEVEL_BY_NAME[level] ?? {
+		label: level.toUpperCase().padEnd(5),
+		color: ANSI.gray
+	} : LEVEL_BY_NUMBER[level] ?? {
+		label: `L${level}`,
+		color: ANSI.gray
+	};
+	const time = formatTime(obj.time);
+	const msg = obj.msg ?? "";
+	const ns = obj.namespace || obj.ns || obj.name || "";
+	const nsTag = ns ? ` ${ANSI.magenta}(${ns})${ANSI.reset}` : "";
+	const arrow = `${ANSI.dim}→${ANSI.reset}`;
+	const data = formatData(obj);
+	return `${ANSI.dim}${time}${ANSI.reset} ${config.color}${config.label}${ANSI.reset}${nsTag} ${arrow} ${msg}${data}`;
 }
-function u() {
-	return new n({ write(e, t, n) {
-		let r = e.toString().split("\n");
-		for (let e of r) {
-			let t = l(e);
-			t && process.stdout.write(t + "\n");
+/**
+* Creates a Node.js writable stream that formats Pino JSON output.
+* Used as the destination for PinoTransport when prettyPrint is enabled.
+*/
+function createPrettyStream() {
+	return new Writable({ write(chunk, _encoding, callback) {
+		const lines = chunk.toString().split("\n");
+		for (const line of lines) {
+			const formatted = formatLogLine(line);
+			if (formatted) process.stdout.write(formatted + "\n");
 		}
-		n();
+		callback();
 	} });
 }
 //#endregion
 //#region src/node.ts
-function d(n = {}) {
-	let { prettyPrint: r, pinoOptions: i, ...a } = n;
-	t.configure({
-		...a,
-		transport: new e({
-			level: a.level,
-			redact: a.redact,
-			destination: a.destination,
-			destinationStream: r ? u() : void 0,
-			pinoOptions: i
+/**
+* Node.js-only exports for @eventuras/logger.
+*
+* These utilities depend on `node:stream` and must not be imported in browser
+* or edge runtime environments. Import from the root entry point
+* (`@eventuras/logger`) for the browser-safe API.
+*
+* @example
+* // Pretty dev output
+* import { configureNodeLogger } from '@eventuras/logger/node';
+* configureNodeLogger({ prettyPrint: process.env.NODE_ENV === 'development' });
+*
+* @example
+* // Lower-level: just the pretty helpers
+* import { createPrettyStream, formatLogLine } from '@eventuras/logger/node';
+*/
+/**
+* Configure the global Logger with a Node-side PinoTransport, optionally
+* wired to a pretty-print stream for development. Keeps the browser/edge
+* main entry free of `node:stream` imports — call this from a Node-only
+* bootstrap (e.g. `instrumentation.ts`, `server.ts`).
+*
+* @example
+* // In your server entry point
+* import { configureNodeLogger } from '@eventuras/logger/node';
+* configureNodeLogger({
+*   level: 'debug',
+*   prettyPrint: process.env.NODE_ENV === 'development',
+* });
+*/
+function configureNodeLogger(options = {}) {
+	const { prettyPrint, pinoOptions, ...rest } = options;
+	Logger.configure({
+		...rest,
+		transport: new PinoTransport({
+			level: rest.level,
+			redact: rest.redact,
+			destination: rest.destination,
+			destinationStream: prettyPrint ? createPrettyStream() : void 0,
+			pinoOptions
 		})
 	});
 }
 //#endregion
-export { d as configureNodeLogger, u as createPrettyStream, l as formatLogLine };
+export { configureNodeLogger, createPrettyStream, formatLogLine };
+
+//# sourceMappingURL=node.js.map

package/dist/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","names":[],"sources":["../src/transports/pretty.ts","../src/node.ts"],"sourcesContent":["/**\n * Lightweight pretty-print formatter for development.\n * Zero external dependencies — uses ANSI colors and simple formatting.\n *\n * Produces output like:\n *   12:34:56 INFO  (web:auth) → User logged in\n *   12:34:56 ERROR (web:auth) → Failed to authenticate { error: \"invalid token\" }\n */\n\nimport { Writable } from 'node:stream';\n\nconst ANSI = {\n  reset: '\\x1b[0m',\n  dim: '\\x1b[2m',\n  bold: '\\x1b[1m',\n  red: '\\x1b[31m',\n  yellow: '\\x1b[33m',\n  green: '\\x1b[32m',\n  cyan: '\\x1b[36m',\n  magenta: '\\x1b[35m',\n  gray: '\\x1b[90m',\n} as const;\n\nconst LEVEL_BY_NUMBER: Record<number, { label: string; color: string; }> = {\n  10: { label: 'TRACE', color: ANSI.gray },\n  20: { label: 'DEBUG', color: ANSI.cyan },\n  30: { label: 'INFO ', color: ANSI.green },\n  40: { label: 'WARN ', color: ANSI.yellow },\n  50: { label: 'ERROR', color: ANSI.red },\n  60: { label: 'FATAL', color: `${ANSI.bold}${ANSI.red}` },\n};\n\nconst LEVEL_BY_NAME: Record<string, { label: string; color: string; }> = {\n  trace: { label: 'TRACE', color: ANSI.gray },\n  debug: { label: 'DEBUG', color: ANSI.cyan },\n  info:  { label: 'INFO ', color: ANSI.green },\n  warn:  { label: 'WARN ', color: ANSI.yellow },\n  error: { label: 'ERROR', color: ANSI.red },\n  fatal: { label: 'FATAL', color: `${ANSI.bold}${ANSI.red}` },\n};\n\n/** Keys excluded from the \"extra data\" output. */\nconst INTERNAL_KEYS = new Set([\n  'level', 'time', 'pid', 'hostname', 'msg', 'name', 'ns', 'namespace',\n]);\n\nfunction formatTime(time: unknown): string {\n  if (typeof time === 'string') {\n    // ISO string — extract time portion\n    const d = new Date(time);\n    return Number.isNaN(d.getTime()) ? '' : d.toLocaleTimeString('en-GB', { hour12: false });\n  }\n  if (typeof time === 'number') {\n    return new Date(time).toLocaleTimeString('en-GB', { hour12: false });\n  }\n  return new Date().toLocaleTimeString('en-GB', { hour12: false });\n}\n\nfunction formatData(obj: Record<string, unknown>): string {\n  const filtered: Record<string, unknown> = {};\n  let hasKeys = false;\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (!INTERNAL_KEYS.has(key)) {\n      filtered[key] = value;\n      hasKeys = true;\n    }\n  }\n\n  if (!hasKeys) return '';\n  return ` ${ANSI.dim}${JSON.stringify(filtered)}${ANSI.reset}`;\n}\n\n/**\n * Format a Pino JSON log line into a human-readable string.\n * @param line Raw JSON string from Pino\n * @returns Formatted string, or the original line if parsing fails\n */\nexport function formatLogLine(line: string): string {\n  const trimmed = line.trim();\n  if (!trimmed) return '';\n\n  let obj: Record<string, unknown>;\n  try {\n    obj = JSON.parse(trimmed);\n  } catch {\n    return trimmed;\n  }\n\n  const level = obj.level;\n  const config = typeof level === 'string'\n    ? LEVEL_BY_NAME[level] ?? { label: level.toUpperCase().padEnd(5), color: ANSI.gray }\n    : LEVEL_BY_NUMBER[level as number] ?? { label: `L${level}`, color: ANSI.gray };\n  const time = formatTime(obj.time);\n  const msg = (obj.msg as string) ?? '';\n  const ns = (obj.namespace as string) || (obj.ns as string) || (obj.name as string) || '';\n\n  const nsTag = ns ? ` ${ANSI.magenta}(${ns})${ANSI.reset}` : '';\n  const arrow = `${ANSI.dim}→${ANSI.reset}`;\n  const data = formatData(obj);\n\n  return `${ANSI.dim}${time}${ANSI.reset} ${config.color}${config.label}${ANSI.reset}${nsTag} ${arrow} ${msg}${data}`;\n}\n\n/**\n * Creates a Node.js writable stream that formats Pino JSON output.\n * Used as the destination for PinoTransport when prettyPrint is enabled.\n */\nexport function createPrettyStream(): NodeJS.WritableStream {\n  return new Writable({\n    write(chunk: Buffer, _encoding: string, callback: () => void) {\n      const lines = chunk.toString().split('\\n');\n      for (const line of lines) {\n        const formatted = formatLogLine(line);\n        if (formatted) {\n          process.stdout.write(formatted + '\\n');\n        }\n      }\n      callback();\n    },\n  });\n}\n","/**\n * Node.js-only exports for @eventuras/logger.\n *\n * These utilities depend on `node:stream` and must not be imported in browser\n * or edge runtime environments. Import from the root entry point\n * (`@eventuras/logger`) for the browser-safe API.\n *\n * @example\n * // Pretty dev output\n * import { configureNodeLogger } from '@eventuras/logger/node';\n * configureNodeLogger({ prettyPrint: process.env.NODE_ENV === 'development' });\n *\n * @example\n * // Lower-level: just the pretty helpers\n * import { createPrettyStream, formatLogLine } from '@eventuras/logger/node';\n */\nimport { Logger } from './Logger';\nimport { PinoTransport, type PinoTransportOptions } from './transports/pino';\nimport { createPrettyStream } from './transports/pretty';\nimport type { LoggerConfig } from './types';\n\nexport { formatLogLine, createPrettyStream } from './transports/pretty';\n\n/** Options for `configureNodeLogger`. */\nexport type NodeLoggerOptions = Omit<LoggerConfig, 'transport'> & {\n  /** Enable human-readable, ANSI-colored output. Off by default. */\n  prettyPrint?: boolean;\n  /** Raw PinoTransport options for advanced tuning. */\n  pinoOptions?: PinoTransportOptions['pinoOptions'];\n};\n\n/**\n * Configure the global Logger with a Node-side PinoTransport, optionally\n * wired to a pretty-print stream for development. Keeps the browser/edge\n * main entry free of `node:stream` imports — call this from a Node-only\n * bootstrap (e.g. `instrumentation.ts`, `server.ts`).\n *\n * @example\n * // In your server entry point\n * import { configureNodeLogger } from '@eventuras/logger/node';\n * configureNodeLogger({\n *   level: 'debug',\n *   prettyPrint: process.env.NODE_ENV === 'development',\n * });\n */\nexport function configureNodeLogger(options: NodeLoggerOptions = {}): void {\n  const { prettyPrint, pinoOptions, ...rest } = options;\n  Logger.configure({\n    ...rest,\n    transport: new PinoTransport({\n      level: rest.level,\n      redact: rest.redact,\n      destination: rest.destination,\n      destinationStream: prettyPrint ? createPrettyStream() : undefined,\n      pinoOptions,\n    }),\n  });\n}\n"],"mappings":"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"}

package/dist/opentelemetry.js

@@ -1,48 +1,158 @@
-import { a as e } from "./chunk-NnHqS4_Y.js";
-import { t } from "./Logger-CcNEmm6u.js";
+import { t as Logger } from "./Logger-n-HsscG5.js";
 //#region src/opentelemetry.ts
-async function n() {
+/**
+* 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
+*/
+async function loadOpenTelemetry() {
 	try {
-		let [t, n] = await Promise.all([import("./src-15l0SmY8.js").then((t) => /* @__PURE__ */ e(t.default, 1)), import("./esm-CIhYjsQQ.js")]);
+		const [pinoModule, logsModule] = await Promise.all([import("@opentelemetry/instrumentation-pino"), import("@opentelemetry/sdk-logs")]);
 		return {
-			PinoInstrumentation: t.PinoInstrumentation,
-			LoggerProvider: n.LoggerProvider
+			PinoInstrumentation: pinoModule.PinoInstrumentation,
+			LoggerProvider: logsModule.LoggerProvider
 		};
 	} catch {
 		return null;
 	}
 }
-var r = null, i = null;
-async function a(e = {}) {
-	if (typeof window < "u") {
-		t.warn({ namespace: "logger:otel" }, "OpenTelemetry integration is server-side only, skipping");
+var pinoInstrumentation = null;
+var loggerProvider = null;
+/**
+* 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
+*   )
+* });
+*/
+async function setupOpenTelemetryLogger(options = {}) {
+	if (typeof window !== "undefined") {
+		Logger.warn({ namespace: "logger:otel" }, "OpenTelemetry integration is server-side only, skipping");
 		return;
 	}
-	let { logRecordProcessor: a, loggerProvider: o, serviceName: s, enabled: c = !0 } = e;
-	if (!c) {
-		t.debug({ namespace: "logger:otel" }, "OpenTelemetry integration disabled");
+	const { logRecordProcessor, loggerProvider: providedLoggerProvider, serviceName, enabled = true } = options;
+	if (!enabled) {
+		Logger.debug({ namespace: "logger:otel" }, "OpenTelemetry integration disabled");
 		return;
 	}
-	let l = await n();
-	if (!l) {
-		t.warn({ namespace: "logger:otel" }, "OpenTelemetry packages not available — integration disabled. Install @opentelemetry/api, @opentelemetry/api-logs, @opentelemetry/instrumentation-pino, and @opentelemetry/sdk-logs to enable.");
+	const otel = await loadOpenTelemetry();
+	if (!otel) {
+		Logger.warn({ namespace: "logger:otel" }, "OpenTelemetry packages not available — integration disabled. Install @opentelemetry/api, @opentelemetry/api-logs, @opentelemetry/instrumentation-pino, and @opentelemetry/sdk-logs to enable.");
 		return;
 	}
-	let { PinoInstrumentation: u, LoggerProvider: d } = l;
-	r &&= (r.disable(), null), i = o ?? new d(), a && i && i.addLogRecordProcessor(a);
-	let f = s ?? (typeof process < "u" ? process.env?.OTEL_SERVICE_NAME : void 0) ?? "unknown-service";
-	r = new u({ logHook: (e, t) => {
-		t["service.name"] = f;
-	} }), r.enable(), t.info({
+	const { PinoInstrumentation, LoggerProvider } = otel;
+	if (pinoInstrumentation) {
+		pinoInstrumentation.disable();
+		pinoInstrumentation = null;
+	}
+	loggerProvider = providedLoggerProvider ?? new LoggerProvider();
+	if (logRecordProcessor && loggerProvider) loggerProvider.addLogRecordProcessor(logRecordProcessor);
+	const resolvedServiceName = serviceName ?? (typeof process !== "undefined" ? process.env?.OTEL_SERVICE_NAME : void 0) ?? "unknown-service";
+	pinoInstrumentation = new PinoInstrumentation({ logHook: (_span, record) => {
+		record["service.name"] = resolvedServiceName;
+	} });
+	pinoInstrumentation.enable();
+	Logger.info({
 		namespace: "logger:otel",
-		context: { hasProcessor: !!a }
+		context: { hasProcessor: Boolean(logRecordProcessor) }
 	}, "OpenTelemetry integration enabled");
 }
-async function o() {
-	typeof window < "u" || (r &&= (r.disable(), null), i &&= (await i.shutdown(), null), t.info({ namespace: "logger:otel" }, "OpenTelemetry integration shut down"));
+/**
+* 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);
+* });
+*/
+async function shutdownOpenTelemetryLogger() {
+	if (typeof window !== "undefined") return;
+	if (pinoInstrumentation) {
+		pinoInstrumentation.disable();
+		pinoInstrumentation = null;
+	}
+	if (loggerProvider) {
+		await loggerProvider.shutdown();
+		loggerProvider = null;
+	}
+	Logger.info({ namespace: "logger:otel" }, "OpenTelemetry integration shut down");
 }
-function s() {
-	return typeof window < "u" ? null : i;
+/**
+* Get the active LoggerProvider instance, if any.
+* Useful for advanced use cases or debugging.
+*/
+function getLoggerProvider() {
+	if (typeof window !== "undefined") return null;
+	return loggerProvider;
 }
 //#endregion
-export { s as getLoggerProvider, a as setupOpenTelemetryLogger, o as shutdownOpenTelemetryLogger };
+export { getLoggerProvider, setupOpenTelemetryLogger, shutdownOpenTelemetryLogger };
+
+//# sourceMappingURL=opentelemetry.js.map

package/dist/opentelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.js","names":[],"sources":["../src/opentelemetry.ts"],"sourcesContent":["/**\n * OpenTelemetry integration for @eventuras/logger\n *\n * This module provides integration between Pino and OpenTelemetry Logs API.\n * It allows sending logs to any OpenTelemetry-compatible backend (Sentry, Grafana, Jaeger, etc.)\n * without vendor lock-in.\n *\n * NOTE: This module requires OpenTelemetry packages to be installed as peer dependencies.\n * If they are not available, the integration will gracefully disable itself.\n *\n * @example\n * // In your app's instrumentation.ts or main entry point\n * import { setupOpenTelemetryLogger } from '@eventuras/logger/opentelemetry';\n * import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';\n * import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';\n *\n * setupOpenTelemetryLogger({\n *   logRecordProcessor: new BatchLogRecordProcessor(\n *     new OTLPLogExporter({\n *       url: 'https://[org].ingest.sentry.io/api/[project]/integration/otlp/v1/logs',\n *       headers: { 'x-sentry-auth': 'sentry sentry_key=...' }\n *     })\n *   )\n * });\n *\n * @example\n * // Then use logger as normal\n * import { Logger } from '@eventuras/logger';\n *\n * const logger = Logger.create({ namespace: 'MyService' });\n * logger.error({ error: err }, 'Something failed'); // Sent to OpenTelemetry backend\n */\n\nimport { Logger } from './Logger';\n\n/**\n * Minimal interface for an OpenTelemetry LogRecordProcessor.\n * Compatible with `@opentelemetry/sdk-logs` `LogRecordProcessor`.\n * Defined locally to avoid requiring OTel types at compile time.\n */\nexport interface LogRecordProcessor {\n  shutdown(): Promise<void>;\n  forceFlush(): Promise<void>;\n}\n\n/**\n * Minimal interface for an OpenTelemetry LoggerProvider.\n * Compatible with `@opentelemetry/sdk-logs` `LoggerProvider`.\n */\nexport interface OTelLoggerProvider {\n  addLogRecordProcessor(processor: LogRecordProcessor): void;\n  shutdown(): Promise<void>;\n  forceFlush?(): Promise<void>;\n}\n\n/** Internal interface for Pino instrumentation */\ninterface PinoInstrumentationInstance {\n  enable(): void;\n  disable(): void;\n}\n\n// Lazy load OpenTelemetry packages to handle optional peer dependencies\nasync function loadOpenTelemetry() {\n  try {\n    const [pinoModule, logsModule] = await Promise.all([\n      import('@opentelemetry/instrumentation-pino'),\n      import('@opentelemetry/sdk-logs'),\n    ]);\n    return {\n      PinoInstrumentation: pinoModule.PinoInstrumentation,\n      LoggerProvider: logsModule.LoggerProvider\n    };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Options for OpenTelemetry logger integration\n */\nexport type OpenTelemetryLoggerOptions = {\n  /**\n   * Log record processor (e.g., BatchLogRecordProcessor with an exporter).\n   * If not provided, logs will only be instrumented but not exported.\n   */\n  logRecordProcessor?: LogRecordProcessor;\n\n  /**\n   * Logger provider instance. If not provided, a new one will be created.\n   */\n  loggerProvider?: OTelLoggerProvider;\n\n  /**\n   * Service name to attach to log records.\n   * Defaults to the `OTEL_SERVICE_NAME` environment variable, or `'unknown-service'`.\n   */\n  serviceName?: string;\n\n  /**\n   * Whether to enable the integration. Default: true\n   */\n  enabled?: boolean;\n};\n\nlet pinoInstrumentation: PinoInstrumentationInstance | null = null;\nlet loggerProvider: OTelLoggerProvider | null = null;\n\n/**\n * Set up OpenTelemetry integration for Pino logger.\n *\n * This function:\n * 1. Creates or uses provided LoggerProvider\n * 2. Registers the log record processor (for exporting logs)\n * 3. Enables Pino instrumentation to bridge Pino logs to OTel\n *\n * Call this function once at application startup, before creating any loggers.\n *\n * @param options - Configuration options\n *\n * @example\n * // Send to Sentry via OTLP\n * import { setupOpenTelemetryLogger } from '@eventuras/logger';\n * import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';\n * import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';\n *\n * setupOpenTelemetryLogger({\n *   logRecordProcessor: new BatchLogRecordProcessor(\n *     new OTLPLogExporter({\n *       url: process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,\n *       headers: {\n *         'x-sentry-auth': `sentry sentry_key=${process.env.SENTRY_KEY}`\n *       }\n *     })\n *   )\n * });\n *\n * @example\n * // Use environment variables (recommended)\n * // Set these in your environment:\n * // OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://[org].ingest.sentry.io/api/[project]/integration/otlp/v1/logs\n * // OTEL_EXPORTER_OTLP_LOGS_HEADERS=x-sentry-auth=sentry sentry_key=...\n *\n * import { setupOpenTelemetryLogger } from '@eventuras/logger';\n * import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';\n * import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';\n *\n * await setupOpenTelemetryLogger({\n *   logRecordProcessor: new BatchLogRecordProcessor(\n *     new OTLPLogExporter() // Reads from env vars\n *   )\n * });\n */\nexport async function setupOpenTelemetryLogger(\n  options: OpenTelemetryLoggerOptions = {}\n): Promise<void> {\n  // Check if we're running in a browser environment\n  if (typeof window !== 'undefined') {\n    Logger.warn({ namespace: 'logger:otel' }, 'OpenTelemetry integration is server-side only, skipping');\n    return;\n  }\n\n  const {\n    logRecordProcessor,\n    loggerProvider: providedLoggerProvider,\n    serviceName,\n    enabled = true,\n  } = options;\n\n  if (!enabled) {\n    Logger.debug({ namespace: 'logger:otel' }, 'OpenTelemetry integration disabled');\n    return;\n  }\n\n  // Lazy load OpenTelemetry packages\n  const otel = await loadOpenTelemetry();\n\n  if (!otel) {\n    Logger.warn(\n      { namespace: 'logger:otel' },\n      'OpenTelemetry packages not available — integration disabled. Install @opentelemetry/api, @opentelemetry/api-logs, @opentelemetry/instrumentation-pino, and @opentelemetry/sdk-logs to enable.',\n    );\n    return;\n  }\n\n  const { PinoInstrumentation, LoggerProvider } = otel;\n\n  // Clean up existing instrumentation if re-initializing\n  if (pinoInstrumentation) {\n    pinoInstrumentation.disable();\n    pinoInstrumentation = null;\n  }\n\n  // Create or use provided logger provider\n  loggerProvider = (providedLoggerProvider ?? new LoggerProvider()) as OTelLoggerProvider;\n\n  // Register log record processor if provided\n  if (logRecordProcessor && loggerProvider) {\n    loggerProvider.addLogRecordProcessor(logRecordProcessor);\n  }\n\n  // Resolve service name from option, env var, or fallback\n  const resolvedServiceName =\n    serviceName ??\n    (typeof process !== 'undefined' ? process.env?.OTEL_SERVICE_NAME : undefined) ??\n    'unknown-service';\n\n  // Enable Pino instrumentation to bridge Pino logs to OpenTelemetry\n  pinoInstrumentation = new PinoInstrumentation({\n    logHook: (_span: unknown, record: Record<string, unknown>) => {\n      record['service.name'] = resolvedServiceName;\n    },\n  }) as PinoInstrumentationInstance;\n\n  pinoInstrumentation.enable();\n\n  Logger.info(\n    { namespace: 'logger:otel', context: { hasProcessor: Boolean(logRecordProcessor) } },\n    'OpenTelemetry integration enabled',\n  );\n}\n\n/**\n * Shut down the OpenTelemetry logger integration.\n * Call this when your application is shutting down to flush any pending logs.\n *\n * @example\n * process.on('SIGTERM', async () => {\n *   await shutdownOpenTelemetryLogger();\n *   process.exit(0);\n * });\n */\nexport async function shutdownOpenTelemetryLogger(): Promise<void> {\n  // Check if we're running in a browser environment\n  if (typeof window !== 'undefined') {\n    return;\n  }\n\n  if (pinoInstrumentation) {\n    pinoInstrumentation.disable();\n    pinoInstrumentation = null;\n  }\n\n  if (loggerProvider) {\n    await loggerProvider.shutdown();\n    loggerProvider = null;\n  }\n\n  Logger.info({ namespace: 'logger:otel' }, 'OpenTelemetry integration shut down');\n}\n\n/**\n * Get the active LoggerProvider instance, if any.\n * Useful for advanced use cases or debugging.\n */\nexport function getLoggerProvider(): OTelLoggerProvider | null {\n  // Return null if in browser environment\n  if (typeof window !== 'undefined') {\n    return null;\n  }\n\n  return loggerProvider;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,eAAe,oBAAoB;AACjC,KAAI;EACF,MAAM,CAAC,YAAY,cAAc,MAAM,QAAQ,IAAI,CACjD,OAAO,wCACP,OAAO,2BACR,CAAC;AACF,SAAO;GACL,qBAAqB,WAAW;GAChC,gBAAgB,WAAW;GAC5B;SACK;AACN,SAAO;;;AA+BX,IAAI,sBAA0D;AAC9D,IAAI,iBAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+ChD,eAAsB,yBACpB,UAAsC,EAAE,EACzB;AAEf,KAAI,OAAO,WAAW,aAAa;AACjC,SAAO,KAAK,EAAE,WAAW,eAAe,EAAE,0DAA0D;AACpG;;CAGF,MAAM,EACJ,oBACA,gBAAgB,wBAChB,aACA,UAAU,SACR;AAEJ,KAAI,CAAC,SAAS;AACZ,SAAO,MAAM,EAAE,WAAW,eAAe,EAAE,qCAAqC;AAChF;;CAIF,MAAM,OAAO,MAAM,mBAAmB;AAEtC,KAAI,CAAC,MAAM;AACT,SAAO,KACL,EAAE,WAAW,eAAe,EAC5B,gMACD;AACD;;CAGF,MAAM,EAAE,qBAAqB,mBAAmB;AAGhD,KAAI,qBAAqB;AACvB,sBAAoB,SAAS;AAC7B,wBAAsB;;AAIxB,kBAAkB,0BAA0B,IAAI,gBAAgB;AAGhE,KAAI,sBAAsB,eACxB,gBAAe,sBAAsB,mBAAmB;CAI1D,MAAM,sBACJ,gBACC,OAAO,YAAY,cAAc,QAAQ,KAAK,oBAAoB,KAAA,MACnE;AAGF,uBAAsB,IAAI,oBAAoB,EAC5C,UAAU,OAAgB,WAAoC;AAC5D,SAAO,kBAAkB;IAE5B,CAAC;AAEF,qBAAoB,QAAQ;AAE5B,QAAO,KACL;EAAE,WAAW;EAAe,SAAS,EAAE,cAAc,QAAQ,mBAAmB,EAAE;EAAE,EACpF,oCACD;;;;;;;;;;;;AAaH,eAAsB,8BAA6C;AAEjE,KAAI,OAAO,WAAW,YACpB;AAGF,KAAI,qBAAqB;AACvB,sBAAoB,SAAS;AAC7B,wBAAsB;;AAGxB,KAAI,gBAAgB;AAClB,QAAM,eAAe,UAAU;AAC/B,mBAAiB;;AAGnB,QAAO,KAAK,EAAE,WAAW,eAAe,EAAE,sCAAsC;;;;;;AAOlF,SAAgB,oBAA+C;AAE7D,KAAI,OAAO,WAAW,YACpB,QAAO;AAGT,QAAO"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventuras/logger",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Structured logging with Pino and optional OpenTelemetry integration",
   "keywords": [
     "logger",
@@ -45,12 +45,12 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/api-logs": "^0.214.0",
-    "@opentelemetry/instrumentation-pino": "^0.60.0",
-    "@opentelemetry/sdk-logs": "^0.214.0",
+    "@opentelemetry/api-logs": "^0.215.0",
+    "@opentelemetry/instrumentation-pino": "^0.61.0",
+    "@opentelemetry/sdk-logs": "^0.215.0",
     "vite": "^8.0.8",
     "vitest": "^4.1.4",
-    "@eventuras/vite-config": "0.2.1"
+    "@eventuras/vite-config": "0.2.2"
   },
   "peerDependencies": {
     "@opentelemetry/api": "^1.9.0",