@eventuras/logger 0.8.0 → 0.9.0

package/dist/opentelemetry.js

@@ -1,48 +1,209 @@
-import { a as e } from "./chunk-NnHqS4_Y.js";
-import { t } from "./Logger-CcNEmm6u.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
-async function n() {
+/**
+* OpenTelemetry integration for @eventuras/logger
+*
+* Sends logs to any OpenTelemetry-compatible backend (Sentry, Grafana, the
+* Aspire dashboard, etc.) without vendor lock-in.
+*
+* 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
+* import { setupOpenTelemetryLogger } from '@eventuras/logger/opentelemetry';
+* import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+* import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+*
+* await setupOpenTelemetryLogger({
+*   logRecordProcessor: new BatchLogRecordProcessor({
+*     exporter: new OTLPLogExporter(), // reads OTEL_EXPORTER_OTLP_* env vars
+*   }),
+* });
+*
+* @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
+*/
+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 {
-		let [t, n] = await Promise.all([import("./src-15l0SmY8.js").then((t) => /* @__PURE__ */ e(t.default, 1)), import("./esm-CIhYjsQQ.js")]);
+		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: t.PinoInstrumentation,
-			LoggerProvider: n.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 r = null, i = null;
-async function a(e = {}) {
-	if (typeof window < "u") {
-		t.warn({ namespace: "logger:otel" }, "OpenTelemetry integration is server-side only, skipping");
+/**
+* Set up OpenTelemetry integration for the logger.
+*
+* 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/opentelemetry';
+* import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+* import { BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+*
+* 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 a provider your app already registered globally (e.g. via NodeSDK)
+* await setupOpenTelemetryLogger();
+*/
+async function setupOpenTelemetryLogger(options = {}) {
+	if (typeof window !== "undefined") {
+		Logger.warn({ namespace: NAMESPACE }, "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 { serviceName, enabled = true } = options;
+	if (!enabled) {
+		Logger.debug({ namespace: NAMESPACE }, "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.");
-		return;
+	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");
 	}
-	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({
-		namespace: "logger:otel",
-		context: { hasProcessor: !!a }
-	}, "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.
+*
+* 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();
+*   process.exit(0);
+* });
+*/
+async function shutdownOpenTelemetryLogger() {
+	if (typeof window !== "undefined") return;
+	setLogLineSink(void 0);
+	if (loggerProvider) {
+		const provider = loggerProvider;
+		loggerProvider = null;
+		await (ownsLoggerProvider ? provider.shutdown?.() : provider.forceFlush?.());
+	}
+	Logger.info({ namespace: NAMESPACE }, "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 * 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/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.0",
+  "version": "0.9.0",
   "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,22 @@
     "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.214.0",
-    "@opentelemetry/instrumentation-pino": "^0.60.0",
-    "@opentelemetry/sdk-logs": "^0.214.0",
-    "vite": "^8.0.8",
-    "vitest": "^4.1.4",
-    "@eventuras/vite-config": "0.2.1"
+    "@opentelemetry/sdk-logs": "^0.222.0",
+    "vite": "^8.1.0",
+    "vitest": "^5.0.0",
+    "@eventuras/eslint-config": "1.0.5",
+    "@eventuras/typescript-config": "1.0.0",
+    "@eventuras/vite-config": "0.3.1"
   },
   "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
     }