@geekmidas/logger 10.0.0-alpha.98 → 10.0.0

package/src/console.ts

@@ -0,0 +1,165 @@
+import type { CreateLoggerOptions, LogFn, Logger } from './types';
+import { LogLevel } from './types';
+
+/**
+ * Numeric priority for log levels (higher = more severe)
+ */
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+	[LogLevel.Trace]: 10,
+	[LogLevel.Debug]: 20,
+	[LogLevel.Info]: 30,
+	[LogLevel.Warn]: 40,
+	[LogLevel.Error]: 50,
+	[LogLevel.Fatal]: 60,
+	[LogLevel.Silent]: 70,
+};
+
+export class ConsoleLogger implements Logger {
+	private readonly level: LogLevel;
+
+	/**
+	 * Creates a new ConsoleLogger instance.
+	 *
+	 * @param data - Initial context data to include in all log messages
+	 * @param level - Minimum log level to output (default: Info)
+	 */
+	constructor(
+		readonly data: object = {},
+		level: LogLevel = LogLevel.Info,
+	) {
+		this.level = level;
+	}
+
+	/**
+	 * Checks if a log level should be output based on the configured minimum level.
+	 */
+	private shouldLog(level: LogLevel): boolean {
+		if (this.level === LogLevel.Silent) {
+			return false;
+		}
+		return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+	}
+
+	/**
+	 * Creates a logging function that merges context data and adds timestamps.
+	 *
+	 * @param logMethod - The console method to use (e.g., console.log, console.error)
+	 * @param level - The log level for this method
+	 * @returns A LogFn that handles both structured and simple logging
+	 * @private
+	 */
+	private createLogFn(
+		logMethod: (...args: any[]) => void,
+		level: LogLevel,
+	): LogFn {
+		return <T extends object>(
+			objOrMsg: T | string,
+			msg?: string,
+			...args: any[]
+		): void => {
+			if (!this.shouldLog(level)) {
+				return;
+			}
+
+			const ts = Date.now();
+
+			// Handle simple string logging: logger.info('message')
+			if (typeof objOrMsg === 'string') {
+				const logData = { ...this.data, msg: objOrMsg, ts };
+				logMethod(logData, ...args);
+				return;
+			}
+
+			// Handle structured logging: logger.info({ data }, 'message')
+			const logData = msg
+				? { ...this.data, ...objOrMsg, msg, ts }
+				: { ...this.data, ...objOrMsg, ts };
+			logMethod(logData, ...args);
+		};
+	}
+
+	/** Trace level logging function */
+	trace: LogFn = this.createLogFn(console.trace.bind(console), LogLevel.Trace);
+	/** Debug level logging function */
+	debug: LogFn = this.createLogFn(console.debug.bind(console), LogLevel.Debug);
+	/** Info level logging function */
+	info: LogFn = this.createLogFn(console.info.bind(console), LogLevel.Info);
+	/** Warning level logging function */
+	warn: LogFn = this.createLogFn(console.warn.bind(console), LogLevel.Warn);
+	/** Error level logging function */
+	error: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Error);
+	/** Fatal level logging function (uses console.error) */
+	fatal: LogFn = this.createLogFn(console.error.bind(console), LogLevel.Fatal);
+
+	/**
+	 * Creates a child logger with additional context data.
+	 * The child logger inherits all context from the parent and adds its own.
+	 *
+	 * @param obj - Additional context data for the child logger
+	 * @returns A new ConsoleLogger instance with merged context
+	 *
+	 * @example
+	 * ```typescript
+	 * const parentLogger = new ConsoleLogger({ app: 'myApp' });
+	 * const childLogger = parentLogger.child({ module: 'database' });
+	 * childLogger.info({ query: 'SELECT * FROM users' }, 'Query executed');
+	 * // Context includes both { app: 'myApp' } and { module: 'database' }
+	 * ```
+	 */
+	child(obj: object): Logger {
+		return new ConsoleLogger(
+			{
+				...this.data,
+				...obj,
+			},
+			this.level,
+		);
+	}
+}
+
+/**
+ * @example Basic usage
+ * ```typescript
+ * const logger = new ConsoleLogger({ app: 'myApp' });
+ * logger.info({ action: 'start' }, 'Application starting');
+ * // Logs: { app: 'myApp', action: 'start', msg: 'Application starting', ts: 1234567890 }
+ * ```
+ *
+ * @example Child logger usage
+ * ```typescript
+ * const childLogger = logger.child({ module: 'auth' });
+ * childLogger.debug({ userId: 123 }, 'User authenticated');
+ * // Logs: { app: 'myApp', module: 'auth', userId: 123, msg: 'User authenticated', ts: 1234567891 }
+ * ```
+ *
+ * @example Error logging with context
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   logger.error({ error, operation: 'someOperation' }, 'Operation failed');
+ * }
+ * ```
+ */
+
+export const DEFAULT_LOGGER = new ConsoleLogger() as any;
+
+/**
+ * Creates a console logger with the same API as pino's createLogger.
+ *
+ * @param options - Logger configuration options
+ * @returns A ConsoleLogger instance
+ *
+ * @example
+ * ```typescript
+ * import { createLogger } from '@geekmidas/logger/console';
+ * import { LogLevel } from '@geekmidas/logger';
+ *
+ * const logger = createLogger({ level: LogLevel.Debug });
+ * logger.debug('This will be logged');
+ * logger.trace('This will NOT be logged (below Debug level)');
+ * ```
+ */
+export function createLogger(options: CreateLoggerOptions = {}): Logger {
+	return new ConsoleLogger({}, options.level ?? LogLevel.Info);
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export {
+	type CreateLoggerOptions,
+	type LogFn,
+	type Logger,
+	LogLevel,
+	type RedactOptions,
+} from './types';

package/src/pino.ts

@@ -0,0 +1,129 @@
+/**
+ * Pino logger with built-in redaction support for sensitive data.
+ *
+ * @example
+ * ```typescript
+ * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';
+ *
+ * // Enable redaction with sensible defaults
+ * const logger = createLogger({ redact: true });
+ *
+ * // Sensitive data is automatically masked
+ * logger.info({ password: 'secret123', user: 'john' }, 'Login');
+ * // Output: { password: '[Redacted]', user: 'john' } Login
+ *
+ * // Add custom paths (merged with defaults)
+ * const logger2 = createLogger({ redact: ['user.ssn'] });
+ *
+ * // Override defaults for full control
+ * const logger3 = createLogger({
+ *   redact: {
+ *     paths: ['onlyThis'],
+ *     resolution: 'override',
+ *   }
+ * });
+ * ```
+ *
+ * @module
+ */
+import { pino } from 'pino';
+import { DEFAULT_REDACT_PATHS } from './redact-paths';
+import type { CreateLoggerOptions, RedactOptions } from './types';
+
+// Re-export for backwards compatibility
+export { DEFAULT_REDACT_PATHS } from './redact-paths';
+
+/**
+ * Type for the resolved pino redact config (without our custom resolution field).
+ */
+type PinoRedactConfig =
+	| string[]
+	| {
+			paths: string[];
+			censor?: string | ((value: unknown, path: string[]) => unknown);
+			remove?: boolean;
+	  };
+
+/**
+ * Resolves redaction configuration from options.
+ * Returns undefined if redaction is disabled, or a pino-compatible redact config.
+ *
+ * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.
+ * With resolution: 'override', only the custom paths are used.
+ */
+function resolveRedactConfig(
+	redact: boolean | RedactOptions | undefined,
+): PinoRedactConfig | undefined {
+	if (redact === undefined || redact === false) {
+		return undefined;
+	}
+
+	if (redact === true) {
+		return DEFAULT_REDACT_PATHS;
+	}
+
+	// Array syntax - merge with defaults
+	if (Array.isArray(redact)) {
+		return [...DEFAULT_REDACT_PATHS, ...redact];
+	}
+
+	// Object syntax - check resolution mode
+	const { resolution = 'merge', paths, censor, remove } = redact;
+
+	const resolvedPaths =
+		resolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];
+
+	// Return clean pino config without our resolution field
+	const config: PinoRedactConfig = { paths: resolvedPaths };
+	if (censor !== undefined) config.censor = censor;
+	if (remove !== undefined) config.remove = remove;
+
+	return config;
+}
+
+/**
+ * Creates a pino logger instance with optional redaction support.
+ *
+ * @param options - Logger configuration options
+ * @returns A configured pino logger instance
+ *
+ * @example
+ * ```typescript
+ * // Basic logger
+ * const logger = createLogger({ level: 'debug' });
+ *
+ * // With redaction enabled
+ * const secureLogger = createLogger({ redact: true });
+ *
+ * // Pretty printing in development
+ * const devLogger = createLogger({ pretty: true, redact: true });
+ * ```
+ */
+export function createLogger(options: CreateLoggerOptions = {}) {
+	// @ts-expect-error
+	const pretty = options?.pretty && process.NODE_ENV !== 'production';
+	const baseOptions = pretty
+		? {
+				transport: {
+					target: 'pino-pretty',
+					options: { colorize: true },
+				},
+			}
+		: {};
+
+	const redact = resolveRedactConfig(options.redact);
+
+	return pino({
+		...baseOptions,
+		...(options.level && { level: options.level }),
+		...(redact && { redact }),
+		formatters: {
+			bindings() {
+				return { nodeVersion: process.version };
+			},
+			level: (label) => {
+				return { level: label.toUpperCase() };
+			},
+		},
+	});
+}

package/src/redact-paths.ts

@@ -0,0 +1,71 @@
+/**
+ * Default sensitive field paths for redaction.
+ *
+ * These paths are automatically used when `redact: true` is set,
+ * and merged with custom paths unless `resolution: 'override'` is specified.
+ *
+ * Includes:
+ * - Authentication: password, token, apiKey, authorization, credentials
+ * - Headers: authorization, cookie, x-api-key, x-auth-token
+ * - Personal data: ssn, creditCard, cvv, pin
+ * - Secrets: secret, connectionString, databaseUrl
+ * - Wildcards: *.password, *.secret, *.token (catches nested fields)
+ */
+export const DEFAULT_REDACT_PATHS: string[] = [
+	// Authentication & authorization
+	'password',
+	'pass',
+	'passwd',
+	'secret',
+	'token',
+	'accessToken',
+	'refreshToken',
+	'idToken',
+	'apiKey',
+	'api_key',
+	'apikey',
+	'auth',
+	'authorization',
+	'credential',
+	'credentials',
+
+	// Common nested patterns (headers, body, etc.)
+	'*.password',
+	'*.secret',
+	'*.token',
+	'*.apiKey',
+	'*.api_key',
+	'*.authorization',
+	'*.accessToken',
+	'*.refreshToken',
+
+	// HTTP headers (case variations)
+	'headers.authorization',
+	'headers.Authorization',
+	'headers["authorization"]',
+	'headers["Authorization"]',
+	'headers.cookie',
+	'headers.Cookie',
+	'headers["x-api-key"]',
+	'headers["X-Api-Key"]',
+	'headers["x-auth-token"]',
+	'headers["X-Auth-Token"]',
+
+	// Common sensitive data fields
+	'ssn',
+	'socialSecurityNumber',
+	'social_security_number',
+	'creditCard',
+	'credit_card',
+	'cardNumber',
+	'card_number',
+	'cvv',
+	'cvc',
+	'pin',
+
+	// Database & connection strings
+	'connectionString',
+	'connection_string',
+	'databaseUrl',
+	'database_url',
+];

package/src/types.ts

@@ -0,0 +1,167 @@
+/**
+ * Logging function type that supports both structured and simple logging.
+ * Can be called with an object for structured logging or just a message string.
+ *
+ * @example
+ * ```typescript
+ * // Structured logging with context object
+ * logger.info({ userId: 123, action: 'login' }, 'User logged in');
+ *
+ * // Simple string logging
+ * logger.info('Application started');
+ * ```
+ */
+export type LogFn = {
+	/** Structured logging with context object, optional message, and additional arguments */
+	<T extends object>(obj: T, msg?: string, ...args: any[]): void;
+	/** Simple string logging */
+	(msg: string): void;
+};
+
+/**
+ * Standard logger interface with multiple log levels and child logger support.
+ * Follows common logging patterns with structured logging capabilities.
+ *
+ * @interface Logger
+ */
+export interface Logger {
+	/** Debug level logging - verbose information for debugging */
+	debug: LogFn;
+	/** Info level logging - general informational messages */
+	info: LogFn;
+	/** Warning level logging - potentially harmful situations */
+	warn: LogFn;
+	/** Error level logging - error events that might still allow the application to continue */
+	error: LogFn;
+	/** Fatal level logging - severe errors that will likely cause the application to abort */
+	fatal: LogFn;
+	/** Trace level logging - most detailed information */
+	trace: LogFn;
+	/**
+	 * Creates a child logger with additional context.
+	 * Child loggers inherit parent context and add their own.
+	 *
+	 * @param obj - Additional context to include in all child logger calls
+	 * @returns A new Logger instance with merged context
+	 */
+	child: (obj: object) => Logger;
+}
+
+/**
+ * Console-based logger implementation that outputs to standard console methods.
+ * Supports structured logging with automatic timestamp injection and context inheritance.
+ *
+ * @implements {Logger}
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });
+ * logger.info({ userId: 123 }, 'User action performed');
+ * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed
+ *
+ * const childLogger = logger.child({ module: 'auth' });
+ * childLogger.debug({ action: 'validate' }, 'Validating token');
+ * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token
+ * ```
+ */
+export enum LogLevel {
+	Trace = 'trace',
+	Debug = 'debug',
+	Info = 'info',
+	Warn = 'warn',
+	Error = 'error',
+	Fatal = 'fatal',
+	Silent = 'silent',
+}
+
+/**
+ * Redaction configuration for masking sensitive data in logs.
+ * Uses pino's fast-redact library under the hood.
+ *
+ * By default, custom paths are merged with the default sensitive paths.
+ * Use `resolution: 'override'` to use only your custom paths.
+ *
+ * @example
+ * ```typescript
+ * // Simple path array (merges with defaults)
+ * redact: ['user.ssn', 'custom.field']
+ *
+ * // Override defaults completely
+ * redact: {
+ *   paths: ['only.these.paths'],
+ *   resolution: 'override',
+ * }
+ *
+ * // With custom censor
+ * redact: {
+ *   paths: ['extra.secret'],
+ *   censor: '***',
+ * }
+ *
+ * // Remove fields entirely
+ * redact: {
+ *   paths: ['temporary.data'],
+ *   remove: true,
+ * }
+ * ```
+ */
+export type RedactOptions =
+	| string[]
+	| {
+			/** Paths to redact using dot notation or bracket notation for special chars */
+			paths: string[];
+			/** Custom replacement text (default: '[REDACTED]') */
+			censor?: string | ((value: unknown, path: string[]) => unknown);
+			/** Remove the field entirely instead of replacing (default: false) */
+			remove?: boolean;
+			/**
+			 * How to combine custom paths with default sensitive paths.
+			 * - 'merge': Custom paths are added to default paths (default)
+			 * - 'override': Only custom paths are used, defaults are ignored
+			 */
+			resolution?: 'merge' | 'override';
+	  };
+
+export type CreateLoggerOptions = {
+	/** Enable pretty printing with colors (disabled in production) */
+	pretty?: boolean;
+	/** Minimum log level to output */
+	level?: LogLevel;
+	/**
+	 * Redaction configuration for masking sensitive data.
+	 *
+	 * - `true`: Uses default sensitive paths (password, token, secret, etc.)
+	 * - `false` or `undefined`: No redaction applied
+	 * - `string[]`: Custom paths merged with defaults
+	 * - `object`: Advanced config with paths, censor, remove, and resolution options
+	 *
+	 * By default, custom paths are **merged** with the default sensitive paths.
+	 * Use `resolution: 'override'` to disable defaults and use only your paths.
+	 *
+	 * @example
+	 * ```typescript
+	 * // Use defaults only
+	 * createLogger({ redact: true });
+	 *
+	 * // Add custom paths (merged with defaults)
+	 * createLogger({ redact: ['user.ssn', 'custom.field'] });
+	 *
+	 * // Override defaults completely
+	 * createLogger({
+	 *   redact: {
+	 *     paths: ['only.these.paths'],
+	 *     resolution: 'override',
+	 *   }
+	 * });
+	 *
+	 * // Merge with custom censor
+	 * createLogger({
+	 *   redact: {
+	 *     paths: ['extra.secret'],
+	 *     censor: '***',
+	 *   }
+	 * });
+	 * ```
+	 */
+	redact?: boolean | RedactOptions;
+};

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"]
+}

package/tsdown.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({});

package/dist/otel.cjs

@@ -1,113 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _opentelemetry_api_logs = require("@opentelemetry/api-logs");
-//#region src/otel.ts
-/**
-* The bridge from pino to OpenTelemetry logs.
-*
-* A pino record is also emitted through `@opentelemetry/api-logs` when a
-* `LoggerProvider` is registered globally — as the generated telemetry setup
-* of a production server does. Nothing hooks module loading, so it works the
-* same in a single bundled file as from `node_modules`.
-*
-* `@opentelemetry/api-logs` keeps its provider on `globalThis` under a
-* `Symbol.for` key, so the copy imported here and the copy the SDK registered
-* through share one provider even when a bundle holds both. That is why the
-* provider is looked up per record rather than once: a logger obtained before
-* the SDK registered — or through another copy's proxy — would stay a no-op.
-*
-* @module
-*/
-/** The instrumentation scope every bridged record carries. */
-const OTEL_SCOPE = "@geekmidas/logger";
-/** Pino's level labels, upper-cased as the logger prints them. */
-const SEVERITY = {
-	TRACE: _opentelemetry_api_logs.SeverityNumber.TRACE,
-	DEBUG: _opentelemetry_api_logs.SeverityNumber.DEBUG,
-	INFO: _opentelemetry_api_logs.SeverityNumber.INFO,
-	WARN: _opentelemetry_api_logs.SeverityNumber.WARN,
-	ERROR: _opentelemetry_api_logs.SeverityNumber.ERROR,
-	FATAL: _opentelemetry_api_logs.SeverityNumber.FATAL
-};
-/** Pino's numeric levels, for a record whose level was not formatted. */
-function severityFromNumber(level) {
-	if (level >= 60) return _opentelemetry_api_logs.SeverityNumber.FATAL;
-	if (level >= 50) return _opentelemetry_api_logs.SeverityNumber.ERROR;
-	if (level >= 40) return _opentelemetry_api_logs.SeverityNumber.WARN;
-	if (level >= 30) return _opentelemetry_api_logs.SeverityNumber.INFO;
-	if (level >= 20) return _opentelemetry_api_logs.SeverityNumber.DEBUG;
-	return _opentelemetry_api_logs.SeverityNumber.TRACE;
-}
-const SEVERITY_TEXT = {
-	[_opentelemetry_api_logs.SeverityNumber.TRACE]: "TRACE",
-	[_opentelemetry_api_logs.SeverityNumber.DEBUG]: "DEBUG",
-	[_opentelemetry_api_logs.SeverityNumber.INFO]: "INFO",
-	[_opentelemetry_api_logs.SeverityNumber.WARN]: "WARN",
-	[_opentelemetry_api_logs.SeverityNumber.ERROR]: "ERROR",
-	[_opentelemetry_api_logs.SeverityNumber.FATAL]: "FATAL"
-};
-let cached;
-/** The bridge's logger from whichever provider is registered now. */
-function otelLogger() {
-	const provider = _opentelemetry_api_logs.logs.getLoggerProvider();
-	if (cached?.provider !== provider) cached = {
-		provider,
-		logger: provider.getLogger(OTEL_SCOPE)
-	};
-	return cached.logger;
-}
-/**
-* Emit one serialized pino line through OpenTelemetry, when a provider is
-* registered that wants it.
-*
-* The line is what pino is about to write — after path redaction and the
-* URL-credential redaction — so the exported copy is exactly as redacted as
-* stdout. It runs synchronously inside the log call, so the active context —
-* and with it the trace and span ids — is the caller's.
-*
-* Without a registered provider the logger is a no-op whose `enabled()` is
-* false, and the line is not parsed.
-*/
-function emitToOtel(line) {
-	const logger = otelLogger();
-	if (!logger.enabled()) return;
-	let record;
-	try {
-		record = JSON.parse(line);
-	} catch {
-		return;
-	}
-	const { level, time, msg, ...attributes } = record;
-	const severityNumber = typeof level === "number" ? severityFromNumber(level) : SEVERITY[String(level).toUpperCase()] ?? _opentelemetry_api_logs.SeverityNumber.UNSPECIFIED;
-	if (!logger.enabled({ severityNumber })) return;
-	logger.emit({
-		severityNumber,
-		severityText: SEVERITY_TEXT[severityNumber] ?? (level === void 0 ? void 0 : String(level)),
-		...msg !== void 0 && { body: String(msg) },
-		...typeof time === "number" && { timestamp: time },
-		attributes
-	});
-}
-/**
-* The bridge as a pino `streamWrite` hook, for a logger made with `pino()`
-* directly rather than `createLogger` — which installs it already.
-*
-* @example
-* ```typescript
-* import pino from 'pino';
-* import { otelStreamWrite } from '@geekmidas/logger/otel';
-*
-* const logger = pino({ hooks: { streamWrite: otelStreamWrite } });
-* ```
-*/
-function otelStreamWrite(line) {
-	try {
-		emitToOtel(line);
-	} catch {}
-	return line;
-}
-//#endregion
-exports.OTEL_SCOPE = OTEL_SCOPE;
-exports.emitToOtel = emitToOtel;
-exports.otelStreamWrite = otelStreamWrite;
-
-//# sourceMappingURL=otel.cjs.map

package/dist/otel.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"otel.cjs","names":["SeverityNumber","logs"],"sources":["../src/otel.ts"],"sourcesContent":["/**\n * The bridge from pino to OpenTelemetry logs.\n *\n * A pino record is also emitted through `@opentelemetry/api-logs` when a\n * `LoggerProvider` is registered globally — as the generated telemetry setup\n * of a production server does. Nothing hooks module loading, so it works the\n * same in a single bundled file as from `node_modules`.\n *\n * `@opentelemetry/api-logs` keeps its provider on `globalThis` under a\n * `Symbol.for` key, so the copy imported here and the copy the SDK registered\n * through share one provider even when a bundle holds both. That is why the\n * provider is looked up per record rather than once: a logger obtained before\n * the SDK registered — or through another copy's proxy — would stay a no-op.\n *\n * @module\n */\nimport {\n\ttype AnyValueMap,\n\ttype Logger,\n\ttype LoggerProvider,\n\tlogs,\n\tSeverityNumber,\n} from '@opentelemetry/api-logs';\n\n/** The instrumentation scope every bridged record carries. */\nexport const OTEL_SCOPE = '@geekmidas/logger';\n\n/** Pino's level labels, upper-cased as the logger prints them. */\nconst SEVERITY: Record<string, SeverityNumber> = {\n\tTRACE: SeverityNumber.TRACE,\n\tDEBUG: SeverityNumber.DEBUG,\n\tINFO: SeverityNumber.INFO,\n\tWARN: SeverityNumber.WARN,\n\tERROR: SeverityNumber.ERROR,\n\tFATAL: SeverityNumber.FATAL,\n};\n\n/** Pino's numeric levels, for a record whose level was not formatted. */\nfunction severityFromNumber(level: number): SeverityNumber {\n\tif (level >= 60) return SeverityNumber.FATAL;\n\tif (level >= 50) return SeverityNumber.ERROR;\n\tif (level >= 40) return SeverityNumber.WARN;\n\tif (level >= 30) return SeverityNumber.INFO;\n\tif (level >= 20) return SeverityNumber.DEBUG;\n\treturn SeverityNumber.TRACE;\n}\n\nconst SEVERITY_TEXT: Partial<Record<SeverityNumber, string>> = {\n\t[SeverityNumber.TRACE]: 'TRACE',\n\t[SeverityNumber.DEBUG]: 'DEBUG',\n\t[SeverityNumber.INFO]: 'INFO',\n\t[SeverityNumber.WARN]: 'WARN',\n\t[SeverityNumber.ERROR]: 'ERROR',\n\t[SeverityNumber.FATAL]: 'FATAL',\n};\n\nlet cached: { provider: LoggerProvider; logger: Logger } | undefined;\n\n/** The bridge's logger from whichever provider is registered now. */\nfunction otelLogger(): Logger {\n\tconst provider = logs.getLoggerProvider();\n\tif (cached?.provider !== provider) {\n\t\tcached = { provider, logger: provider.getLogger(OTEL_SCOPE) };\n\t}\n\treturn cached.logger;\n}\n\n/**\n * Emit one serialized pino line through OpenTelemetry, when a provider is\n * registered that wants it.\n *\n * The line is what pino is about to write — after path redaction and the\n * URL-credential redaction — so the exported copy is exactly as redacted as\n * stdout. It runs synchronously inside the log call, so the active context —\n * and with it the trace and span ids — is the caller's.\n *\n * Without a registered provider the logger is a no-op whose `enabled()` is\n * false, and the line is not parsed.\n */\nexport function emitToOtel(line: string): void {\n\tconst logger = otelLogger();\n\tif (!logger.enabled()) return;\n\n\tlet record: Record<string, unknown>;\n\ttry {\n\t\trecord = JSON.parse(line);\n\t} catch {\n\t\treturn;\n\t}\n\n\tconst { level, time, msg, ...attributes } = record;\n\tconst severityNumber =\n\t\ttypeof level === 'number'\n\t\t\t? severityFromNumber(level)\n\t\t\t: (SEVERITY[String(level).toUpperCase()] ?? SeverityNumber.UNSPECIFIED);\n\n\tif (!logger.enabled({ severityNumber })) return;\n\n\tlogger.emit({\n\t\tseverityNumber,\n\t\tseverityText:\n\t\t\tSEVERITY_TEXT[severityNumber] ??\n\t\t\t(level === undefined ? undefined : String(level)),\n\t\t...(msg !== undefined && { body: String(msg) }),\n\t\t...(typeof time === 'number' && { timestamp: time }),\n\t\tattributes: attributes as AnyValueMap,\n\t});\n}\n\n/**\n * The bridge as a pino `streamWrite` hook, for a logger made with `pino()`\n * directly rather than `createLogger` — which installs it already.\n *\n * @example\n * ```typescript\n * import pino from 'pino';\n * import { otelStreamWrite } from '@geekmidas/logger/otel';\n *\n * const logger = pino({ hooks: { streamWrite: otelStreamWrite } });\n * ```\n */\nexport function otelStreamWrite(line: string): string {\n\ttry {\n\t\temitToOtel(line);\n\t} catch {\n\t\t// Exporting a log is never a reason to lose it from stdout.\n\t}\n\treturn line;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,aAAa;;AAG1B,MAAM,WAA2C;CAChD,OAAOA,wBAAAA,eAAe;CACtB,OAAOA,wBAAAA,eAAe;CACtB,MAAMA,wBAAAA,eAAe;CACrB,MAAMA,wBAAAA,eAAe;CACrB,OAAOA,wBAAAA,eAAe;CACtB,OAAOA,wBAAAA,eAAe;AACvB;;AAGA,SAAS,mBAAmB,OAA+B;CAC1D,IAAI,SAAS,IAAI,OAAOA,wBAAAA,eAAe;CACvC,IAAI,SAAS,IAAI,OAAOA,wBAAAA,eAAe;CACvC,IAAI,SAAS,IAAI,OAAOA,wBAAAA,eAAe;CACvC,IAAI,SAAS,IAAI,OAAOA,wBAAAA,eAAe;CACvC,IAAI,SAAS,IAAI,OAAOA,wBAAAA,eAAe;CACvC,OAAOA,wBAAAA,eAAe;AACvB;AAEA,MAAM,gBAAyD;EAC7DA,wBAAAA,eAAe,QAAQ;EACvBA,wBAAAA,eAAe,QAAQ;EACvBA,wBAAAA,eAAe,OAAO;EACtBA,wBAAAA,eAAe,OAAO;EACtBA,wBAAAA,eAAe,QAAQ;EACvBA,wBAAAA,eAAe,QAAQ;AACzB;AAEA,IAAI;;AAGJ,SAAS,aAAqB;CAC7B,MAAM,WAAWC,wBAAAA,KAAK,kBAAkB;CACxC,IAAI,QAAQ,aAAa,UACxB,SAAS;EAAE;EAAU,QAAQ,SAAS,UAAU,UAAU;CAAE;CAE7D,OAAO,OAAO;AACf;;;;;;;;;;;;;AAcA,SAAgB,WAAW,MAAoB;CAC9C,MAAM,SAAS,WAAW;CAC1B,IAAI,CAAC,OAAO,QAAQ,GAAG;CAEvB,IAAI;CACJ,IAAI;EACH,SAAS,KAAK,MAAM,IAAI;CACzB,QAAQ;EACP;CACD;CAEA,MAAM,EAAE,OAAO,MAAM,KAAK,GAAG,eAAe;CAC5C,MAAM,iBACL,OAAO,UAAU,WACd,mBAAmB,KAAK,IACvB,SAAS,OAAO,KAAK,CAAC,CAAC,YAAY,MAAMD,wBAAAA,eAAe;CAE7D,IAAI,CAAC,OAAO,QAAQ,EAAE,eAAe,CAAC,GAAG;CAEzC,OAAO,KAAK;EACX;EACA,cACC,cAAc,oBACb,UAAU,KAAA,IAAY,KAAA,IAAY,OAAO,KAAK;EAChD,GAAI,QAAQ,KAAA,KAAa,EAAE,MAAM,OAAO,GAAG,EAAE;EAC7C,GAAI,OAAO,SAAS,YAAY,EAAE,WAAW,KAAK;EACtC;CACb,CAAC;AACF;;;;;;;;;;;;;AAcA,SAAgB,gBAAgB,MAAsB;CACrD,IAAI;EACH,WAAW,IAAI;CAChB,QAAQ,CAER;CACA,OAAO;AACR"}