@eventuras/logger 0.8.1 → 0.9.1

package/dist/opentelemetry.js

@@ -1,14 +1,25 @@
-import { t as Logger } from "./Logger-n-HsscG5.js";
+import { i as setLogLineSink, r as PinoTransport, t as Logger } from "./Logger-B22dX10w.js";
+import { logs } from "@opentelemetry/api-logs";
 //#region src/opentelemetry.ts
 /**
 * 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.
+* Sends logs to any OpenTelemetry-compatible backend (Sentry, Grafana, the
+* Aspire dashboard, 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.
+* Every line the Pino transport writes — after redaction, from every logger,
+* including ones created before setup — is also emitted as an OpenTelemetry
+* log record. The logger bridges this itself rather than through
+* `@opentelemetry/instrumentation-pino`, which only patches Pino when it is
+* loaded through an import-in-the-middle loader hook, and so never saw this
+* package's ESM import of Pino.
+*
+* `@opentelemetry/sdk-logs` is an optional peer dependency, needed only when
+* passing `logRecordProcessor` — which comes from that package anyway, so the
+* app already has it and the logger uses the app's copy.
+*
+* Setup never throws or rejects: if it can't start, it logs an error and
+* leaves logging to stdout untouched.
 *
 * @example
 * // In your app's instrumentation.ts or main entry point
@@ -16,13 +27,10 @@ import { t as Logger } from "./Logger-n-HsscG5.js";
 * 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=...' }
-*     })
-*   )
+* await setupOpenTelemetryLogger({
+*   logRecordProcessor: new BatchLogRecordProcessor({
+*     exporter: new OTLPLogExporter(), // reads OTEL_EXPORTER_OTLP_* env vars
+*   }),
 * });
 *
 * @example
@@ -32,100 +40,145 @@ import { t as Logger } from "./Logger-n-HsscG5.js";
 * const logger = Logger.create({ namespace: 'MyService' });
 * logger.error({ error: err }, 'Something failed'); // Sent to OpenTelemetry backend
 */
-async function loadOpenTelemetry() {
+var NAMESPACE = "logger:otel";
+var INSTRUMENTATION_SCOPE = "@eventuras/logger";
+/** OpenTelemetry severity numbers for each level (logs data model). */
+var SEVERITY_NUMBERS = {
+	trace: 1,
+	debug: 5,
+	info: 9,
+	warn: 13,
+	error: 17,
+	fatal: 21
+};
+/** Pino's numeric levels, for when `formatters.level` has been overridden. */
+var PINO_LEVEL_LABELS = {
+	10: "trace",
+	20: "debug",
+	30: "info",
+	40: "warn",
+	50: "error",
+	60: "fatal"
+};
+var loggerProvider = null;
+/** Whether `loggerProvider` was created here — only then is it ours to shut down. */
+var ownsLoggerProvider = false;
+async function loadPeer(name, load) {
 	try {
-		const [pinoModule, logsModule] = await Promise.all([import("@opentelemetry/instrumentation-pino"), import("@opentelemetry/sdk-logs")]);
+		return await load();
+	} catch (cause) {
+		const reason = cause instanceof Error ? cause.message : String(cause);
+		throw new Error(`${name} could not be loaded (${reason}). Install it to export logs with OpenTelemetry.`, { cause });
+	}
+}
+async function resolveLoggerProvider(options) {
+	if (options.loggerProvider) return {
+		provider: options.loggerProvider,
+		owned: false
+	};
+	if (options.logRecordProcessor) {
+		const { LoggerProvider } = await loadPeer("@opentelemetry/sdk-logs", () => import("@opentelemetry/sdk-logs"));
 		return {
-			PinoInstrumentation: pinoModule.PinoInstrumentation,
-			LoggerProvider: logsModule.LoggerProvider
+			provider: new LoggerProvider({ processors: [options.logRecordProcessor] }),
+			owned: true
 		};
-	} catch {
-		return null;
 	}
+	return {
+		provider: logs.getLoggerProvider(),
+		owned: false
+	};
+}
+function formatBody(msg) {
+	if (Array.isArray(msg)) return msg.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join(" ");
+	return msg;
+}
+/** Map a serialized Pino line to an OpenTelemetry log record. */
+function toLogRecord(line, serviceName) {
+	const { level, time, msg, ...attributes } = JSON.parse(line);
+	delete attributes.pid;
+	delete attributes.hostname;
+	const label = typeof level === "number" ? PINO_LEVEL_LABELS[level] : String(level);
+	const timestamp = new Date(typeof time === "string" || typeof time === "number" ? time : Date.now());
+	return {
+		timestamp: Number.isNaN(timestamp.getTime()) ? /* @__PURE__ */ new Date() : timestamp,
+		severityNumber: label ? SEVERITY_NUMBERS[label] : void 0,
+		severityText: label,
+		body: formatBody(msg),
+		attributes: {
+			...attributes,
+			"service.name": serviceName
+		}
+	};
 }
-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
+* Set up OpenTelemetry integration for the logger.
 *
-* Call this function once at application startup, before creating any loggers.
+* Call once at application startup. Loggers created before the call are
+* exported too. Calling again replaces the previous setup.
 *
 * @param options - Configuration options
 *
 * @example
 * // Send to Sentry via OTLP
-* import { setupOpenTelemetryLogger } from '@eventuras/logger';
+* 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({
+* await setupOpenTelemetryLogger({
+*   logRecordProcessor: new BatchLogRecordProcessor({
+*     exporter: 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
-*   )
-* });
+* // Use a provider your app already registered globally (e.g. via NodeSDK)
+* await setupOpenTelemetryLogger();
 */
 async function setupOpenTelemetryLogger(options = {}) {
 	if (typeof window !== "undefined") {
-		Logger.warn({ namespace: "logger:otel" }, "OpenTelemetry integration is server-side only, skipping");
+		Logger.warn({ namespace: NAMESPACE }, "OpenTelemetry integration is server-side only, skipping");
 		return;
 	}
-	const { logRecordProcessor, loggerProvider: providedLoggerProvider, serviceName, enabled = true } = options;
+	const { serviceName, enabled = true } = options;
 	if (!enabled) {
-		Logger.debug({ namespace: "logger:otel" }, "OpenTelemetry integration disabled");
-		return;
-	}
-	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.");
+		Logger.debug({ namespace: NAMESPACE }, "OpenTelemetry integration disabled");
 		return;
 	}
-	const { PinoInstrumentation, LoggerProvider } = otel;
-	if (pinoInstrumentation) {
-		pinoInstrumentation.disable();
-		pinoInstrumentation = null;
+	try {
+		const { provider, owned } = await resolveLoggerProvider(options);
+		const otelLogger = provider.getLogger(INSTRUMENTATION_SCOPE);
+		setLogLineSink(void 0);
+		if (loggerProvider && ownsLoggerProvider && loggerProvider !== provider) await loggerProvider.shutdown?.();
+		loggerProvider = provider;
+		ownsLoggerProvider = owned;
+		const resolvedServiceName = serviceName ?? (typeof process !== "undefined" ? process.env?.OTEL_SERVICE_NAME : void 0) ?? "unknown-service";
+		setLogLineSink((line) => otelLogger.emit(toLogRecord(line, resolvedServiceName)));
+		if (!(Logger.getTransport() instanceof PinoTransport)) Logger.warn({ namespace: NAMESPACE }, "The active transport is not PinoTransport — only PinoTransport output is exported to OpenTelemetry");
+		const source = options.loggerProvider ? "loggerProvider" : options.logRecordProcessor ? "logRecordProcessor" : "global";
+		Logger.info({
+			namespace: NAMESPACE,
+			context: { source }
+		}, "OpenTelemetry integration enabled");
+	} catch (error) {
+		Logger.error({
+			namespace: NAMESPACE,
+			error
+		}, "OpenTelemetry integration failed to start — logs are not exported");
 	}
-	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: Boolean(logRecordProcessor) }
-	}, "OpenTelemetry integration enabled");
 }
 /**
 * Shut down the OpenTelemetry logger integration.
 * Call this when your application is shutting down to flush any pending logs.
 *
+* A provider created from `logRecordProcessor` is shut down. One passed as
+* `loggerProvider`, or the global one, belongs to your app — it is flushed,
+* not shut down.
+*
 * @example
 * process.on('SIGTERM', async () => {
 *   await shutdownOpenTelemetryLogger();
@@ -134,15 +187,13 @@ async function setupOpenTelemetryLogger(options = {}) {
 */
 async function shutdownOpenTelemetryLogger() {
 	if (typeof window !== "undefined") return;
-	if (pinoInstrumentation) {
-		pinoInstrumentation.disable();
-		pinoInstrumentation = null;
-	}
+	setLogLineSink(void 0);
 	if (loggerProvider) {
-		await loggerProvider.shutdown();
+		const provider = loggerProvider;
 		loggerProvider = null;
+		await (ownsLoggerProvider ? provider.shutdown?.() : provider.forceFlush?.());
 	}
-	Logger.info({ namespace: "logger:otel" }, "OpenTelemetry integration shut down");
+	Logger.info({ namespace: NAMESPACE }, "OpenTelemetry integration shut down");
 }
 /**
 * Get the active LoggerProvider instance, if any.

package/dist/opentelemetry.js.map

@@ -1 +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"}
+{"version":3,"file":"opentelemetry.js","names":[],"sources":["../src/opentelemetry.ts"],"sourcesContent":["/**\n * OpenTelemetry integration for @eventuras/logger\n *\n * Sends logs to any OpenTelemetry-compatible backend (Sentry, Grafana, the\n * Aspire dashboard, etc.) without vendor lock-in.\n *\n * Every line the Pino transport writes — after redaction, from every logger,\n * including ones created before setup — is also emitted as an OpenTelemetry\n * log record. The logger bridges this itself rather than through\n * `@opentelemetry/instrumentation-pino`, which only patches Pino when it is\n * loaded through an import-in-the-middle loader hook, and so never saw this\n * package's ESM import of Pino.\n *\n * `@opentelemetry/sdk-logs` is an optional peer dependency, needed only when\n * passing `logRecordProcessor` — which comes from that package anyway, so the\n * app already has it and the logger uses the app's copy.\n *\n * Setup never throws or rejects: if it can't start, it logs an error and\n * leaves logging to stdout untouched.\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 * await setupOpenTelemetryLogger({\n *   logRecordProcessor: new BatchLogRecordProcessor({\n *     exporter: new OTLPLogExporter(), // reads OTEL_EXPORTER_OTLP_* env vars\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 { logs } from '@opentelemetry/api-logs';\nimport { Logger } from './Logger';\nimport { setLogLineSink } from './sink';\nimport { PinoTransport } from './transports/pino';\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  onEmit(logRecord: unknown, context?: unknown): void;\n  shutdown(): Promise<void>;\n  forceFlush(): Promise<void>;\n}\n\n/**\n * Minimal shape of an OpenTelemetry log record, as emitted by this package.\n * Loosely typed so the SDK's own `LogRecord` type is assignable to it.\n */\nexport type OTelLogRecord = {\n  timestamp?: unknown;\n  severityNumber?: number;\n  severityText?: string;\n  body?: unknown;\n  attributes?: Record<string, unknown>;\n};\n\n/**\n * Minimal interface for an OpenTelemetry Logger.\n * Compatible with `@opentelemetry/api-logs` `Logger`.\n */\nexport interface OTelLogger {\n  emit(record: OTelLogRecord): void;\n}\n\n/**\n * Minimal interface for an OpenTelemetry LoggerProvider.\n * Compatible with `@opentelemetry/sdk-logs` `LoggerProvider` and the global\n * provider from `@opentelemetry/api-logs`.\n */\nexport interface OTelLoggerProvider {\n  getLogger(name: string, version?: string): OTelLogger;\n  shutdown?(): Promise<void>;\n  forceFlush?(): Promise<void>;\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   * A LoggerProvider is created for it. Requires `@opentelemetry/sdk-logs`.\n   */\n  logRecordProcessor?: LogRecordProcessor;\n\n  /**\n   * Logger provider to emit to, e.g. one your app already configured with a\n   * resource and processors. Takes precedence over `logRecordProcessor`.\n   *\n   * With neither option, the globally registered provider is used (as set up\n   * by `@opentelemetry/sdk-node`, for instance).\n   */\n  loggerProvider?: OTelLoggerProvider;\n\n  /**\n   * Service name attached to every log record as the `service.name` attribute.\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\nconst NAMESPACE = 'logger:otel';\nconst INSTRUMENTATION_SCOPE = '@eventuras/logger';\n\n/** OpenTelemetry severity numbers for each level (logs data model). */\nconst SEVERITY_NUMBERS: Record<string, number> = {\n  trace: 1,\n  debug: 5,\n  info: 9,\n  warn: 13,\n  error: 17,\n  fatal: 21,\n};\n\n/** Pino's numeric levels, for when `formatters.level` has been overridden. */\nconst PINO_LEVEL_LABELS: Record<number, string> = {\n  10: 'trace',\n  20: 'debug',\n  30: 'info',\n  40: 'warn',\n  50: 'error',\n  60: 'fatal',\n};\n\nlet loggerProvider: OTelLoggerProvider | null = null;\n/** Whether `loggerProvider` was created here — only then is it ours to shut down. */\nlet ownsLoggerProvider = false;\n\nasync function loadPeer<T>(name: string, load: () => Promise<T>): Promise<T> {\n  try {\n    return await load();\n  } catch (cause) {\n    const reason = cause instanceof Error ? cause.message : String(cause);\n    throw new Error(`${name} could not be loaded (${reason}). Install it to export logs with OpenTelemetry.`, {\n      cause,\n    });\n  }\n}\n\nasync function resolveLoggerProvider(\n  options: OpenTelemetryLoggerOptions,\n): Promise<{ provider: OTelLoggerProvider; owned: boolean }> {\n  if (options.loggerProvider) {\n    return { provider: options.loggerProvider, owned: false };\n  }\n\n  if (options.logRecordProcessor) {\n    const { LoggerProvider } = await loadPeer('@opentelemetry/sdk-logs', () => import('@opentelemetry/sdk-logs'));\n    return { provider: new LoggerProvider({ processors: [options.logRecordProcessor] }), owned: true };\n  }\n\n  return { provider: logs.getLoggerProvider(), owned: false };\n}\n\nfunction formatBody(msg: unknown): unknown {\n  // Static methods (`Logger.info(options, 'a', 'b')`) log `msg` as an array.\n  if (Array.isArray(msg)) {\n    return msg.map((part) => (typeof part === 'string' ? part : JSON.stringify(part))).join(' ');\n  }\n  return msg;\n}\n\n/** Map a serialized Pino line to an OpenTelemetry log record. */\nfunction toLogRecord(line: string, serviceName: string): OTelLogRecord {\n  const { level, time, msg, ...attributes } = JSON.parse(line) as Record<string, unknown>;\n\n  // Redundant with the `host.name` and `process.pid` resource attributes.\n  delete attributes.pid;\n  delete attributes.hostname;\n\n  const label = typeof level === 'number' ? PINO_LEVEL_LABELS[level] : String(level);\n  const timestamp = new Date(typeof time === 'string' || typeof time === 'number' ? time : Date.now());\n\n  return {\n    timestamp: Number.isNaN(timestamp.getTime()) ? new Date() : timestamp,\n    severityNumber: label ? SEVERITY_NUMBERS[label] : undefined,\n    severityText: label,\n    body: formatBody(msg),\n    attributes: { ...attributes, 'service.name': serviceName },\n  };\n}\n\n/**\n * Set up OpenTelemetry integration for the logger.\n *\n * Call once at application startup. Loggers created before the call are\n * exported too. Calling again replaces the previous setup.\n *\n * @param options - Configuration options\n *\n * @example\n * // Send to Sentry via OTLP\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 * await setupOpenTelemetryLogger({\n *   logRecordProcessor: new BatchLogRecordProcessor({\n *     exporter: 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 a provider your app already registered globally (e.g. via NodeSDK)\n * await setupOpenTelemetryLogger();\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: NAMESPACE }, 'OpenTelemetry integration is server-side only, skipping');\n    return;\n  }\n\n  const { serviceName, enabled = true } = options;\n\n  if (!enabled) {\n    Logger.debug({ namespace: NAMESPACE }, 'OpenTelemetry integration disabled');\n    return;\n  }\n\n  try {\n    const { provider, owned } = await resolveLoggerProvider(options);\n    const otelLogger = provider.getLogger(INSTRUMENTATION_SCOPE);\n\n    // Replace any previous setup, releasing a provider created here.\n    setLogLineSink(undefined);\n    if (loggerProvider && ownsLoggerProvider && loggerProvider !== provider) {\n      await loggerProvider.shutdown?.();\n    }\n    loggerProvider = provider;\n    ownsLoggerProvider = owned;\n\n    const resolvedServiceName =\n      serviceName ??\n      (typeof process !== 'undefined' ? process.env?.OTEL_SERVICE_NAME : undefined) ??\n      'unknown-service';\n\n    setLogLineSink((line) => otelLogger.emit(toLogRecord(line, resolvedServiceName)));\n\n    if (!(Logger.getTransport() instanceof PinoTransport)) {\n      Logger.warn(\n        { namespace: NAMESPACE },\n        'The active transport is not PinoTransport — only PinoTransport output is exported to OpenTelemetry',\n      );\n    }\n\n    const source = options.loggerProvider\n      ? 'loggerProvider'\n      : options.logRecordProcessor\n        ? 'logRecordProcessor'\n        : 'global';\n    Logger.info({ namespace: NAMESPACE, context: { source } }, 'OpenTelemetry integration enabled');\n  } catch (error) {\n    Logger.error(\n      { namespace: NAMESPACE, error },\n      'OpenTelemetry integration failed to start — logs are not exported',\n    );\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 * A provider created from `logRecordProcessor` is shut down. One passed as\n * `loggerProvider`, or the global one, belongs to your app — it is flushed,\n * not shut down.\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  setLogLineSink(undefined);\n\n  if (loggerProvider) {\n    const provider = loggerProvider;\n    loggerProvider = null;\n    await (ownsLoggerProvider ? provider.shutdown?.() : provider.forceFlush?.());\n  }\n\n  Logger.info({ namespace: NAMESPACE }, '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":"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"}

package/dist/sink.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Process-wide hook for the serialized log lines Pino writes.
+ *
+ * `PinoTransport` hands every line (after redaction) to the sink, and
+ * `@eventuras/logger/opentelemetry` sets the sink to forward lines as
+ * OpenTelemetry log records.
+ *
+ * The sink lives on `globalThis` rather than in module state because a
+ * bundler can load this package more than once in one process — Next.js
+ * compiles `instrumentation.ts` into its own layer — and the copy that sets
+ * the sink up is not necessarily the one whose loggers write the lines.
+ */
+export type LogLineSink = (line: string) => void;
+export declare function setLogLineSink(sink: LogLineSink | undefined): void;
+/** Forward a line to the sink, if any. Never throws — telemetry must not break logging. */
+export declare function forwardLogLine(line: string): void;
+//# sourceMappingURL=sink.d.ts.map

package/dist/sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../src/sink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAMjD,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAElE;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CASjD"}

package/dist/transports/console.d.ts

@@ -1,4 +1,10 @@
-import { LogLevel, LogTransport } from '../types';
+/**
+ * Console-based transport for browser environments and testing.
+ *
+ * Uses `console.log/warn/error` — no dependencies, works everywhere.
+ * Useful as a lightweight fallback when Pino is not available or desired.
+ */
+import type { LogLevel, LogTransport } from '../types';
 export declare class ConsoleTransport implements LogTransport {
     private readonly bindings;
     /** Create a ConsoleTransport with optional pre-bound context fields. */

package/dist/transports/pino.d.ts

@@ -1,5 +1,15 @@
-import { Logger as PinoLogger, LoggerOptions as PinoLoggerOptions } from 'pino';
-import { LogLevel, LogTransport } from '../types';
+/**
+ * Pino-based transport — the default production backend.
+ *
+ * Wraps a Pino logger instance to satisfy the `LogTransport` interface,
+ * keeping Pino as an implementation detail that consumers never interact with directly.
+ *
+ * For pretty-printed dev output, see `configureNodeLogger` in
+ * `@eventuras/logger/node` — this module intentionally stays free of
+ * `node:stream` imports so the main entry stays browser/edge-safe.
+ */
+import { type Logger as PinoLogger, type LoggerOptions as PinoLoggerOptions } from 'pino';
+import type { LogLevel, LogTransport } from '../types';
 /**
  * Minimal structural type for a Pino destination stream — accepts anything
  * with a `write` method. Defined locally so this file (re-exported from the

package/dist/transports/pino.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pino.d.ts","sourceRoot":"","sources":["../../src/transports/pino.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAa,EAAE,KAAK,MAAM,IAAI,UAAU,EAAE,KAAK,aAAa,IAAI,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAChG,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;CAC5C;AAED,4CAA4C;AAC5C,MAAM,MAAM,oBAAoB,GAAG;IACjC,+CAA+C;IAC/C,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAC1C,6EAA6E;IAC7E,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC,CAAC;AAEF,qBAAa,aAAc,YAAW,YAAY;IAChD,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;gBAEd,OAAO,GAAE,oBAAyB;IA2B9C,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAQvE,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;IAKhD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}
+{"version":3,"file":"pino.d.ts","sourceRoot":"","sources":["../../src/transports/pino.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAa,EAAE,KAAK,MAAM,IAAI,UAAU,EAAE,KAAK,aAAa,IAAI,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAEhG,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;CAC5C;AAED,4CAA4C;AAC5C,MAAM,MAAM,oBAAoB,GAAG;IACjC,+CAA+C;IAC/C,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAC1C,6EAA6E;IAC7E,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC,CAAC;AAEF,qBAAa,aAAc,YAAW,YAAY;IAChD,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;gBAEd,OAAO,GAAE,oBAAyB;IAwC9C,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAQvE,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,YAAY;IAKhD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventuras/logger",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "description": "Structured logging with Pino and optional OpenTelemetry integration",
   "keywords": [
     "logger",
@@ -10,14 +10,14 @@
     "opentelemetry",
     "otel"
   ],
-  "homepage": "https://github.com/losol/eventuras/tree/main/libs/logger#readme",
+  "homepage": "https://github.com/losol/origo/tree/main/packages/logger#readme",
   "bugs": {
-    "url": "https://github.com/losol/eventuras/issues"
+    "url": "https://github.com/losol/origo/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/losol/eventuras.git",
-    "directory": "libs/logger"
+    "url": "https://github.com/losol/origo.git",
+    "directory": "packages/logger"
   },
   "license": "Apache-2.0",
   "type": "module",
@@ -41,33 +41,23 @@
     "dist"
   ],
   "dependencies": {
+    "@opentelemetry/api-logs": ">=0.200.0 <1.0.0",
     "pino": "^10.3.1"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@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.2"
+    "@opentelemetry/sdk-logs": "^0.222.0",
+    "typescript": "^6.0.2",
+    "vite": "^8.1.0",
+    "vitest": "^5.0.0",
+    "@eventuras/eslint-config": "1.0.5",
+    "@eventuras/typescript-config": "1.1.0",
+    "@eventuras/vite-config": "0.4.0"
   },
   "peerDependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": ">=0.200.0 <1.0.0",
-    "@opentelemetry/instrumentation-pino": ">=0.50.0 <1.0.0",
     "@opentelemetry/sdk-logs": ">=0.200.0 <1.0.0"
   },
   "peerDependenciesMeta": {
-    "@opentelemetry/api": {
-      "optional": true
-    },
-    "@opentelemetry/api-logs": {
-      "optional": true
-    },
-    "@opentelemetry/instrumentation-pino": {
-      "optional": true
-    },
     "@opentelemetry/sdk-logs": {
       "optional": true
     }
@@ -76,7 +66,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && tsc -p tsconfig.build.json --emitDeclarationOnly",
     "dev": "vite build --watch",
     "test": "vitest run",
     "test:watch": "vitest"