@geekmidas/logger 10.0.0-alpha.14 → 10.0.0-alpha.141

package/dist/console.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"console.d.cts","names":[],"sources":["../src/console.ts"],"mappings":";;qBAgBa,yBAAyB;WAU3B;mBATO;;;;;;;EASP,YAAA,eACT,QAAO;;;;UAQA;;;;;;;;;UAeA;;EA+BR,OAAO;;EAEP,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;;;;;;;;;;;;;;;EAiBP,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCR;;;;;;;;;;;;;;;;;wBAkBG,aAAa,UAAS,sBAA2B"}
+{"version":3,"file":"console.d.cts","names":[],"sources":["../src/console.ts"],"mappings":";;qBAgBa,yBAAyB;WAU3B;mBATO;;;;;;;EAQjB,YACU,eACT,QAAO;;;;UAQA;;;;;;;;;UAeA;;EA+BR,OAAO;;EAEP,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;;;;;;;;;;;;;;;EAiBP,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCR;;;;;;;;;;;;;;;;;wBAkBG,aAAa,UAAS,sBAA2B"}

package/dist/console.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"console.d.mts","names":[],"sources":["../src/console.ts"],"mappings":";;qBAgBa,yBAAyB;WAU3B;mBATO;;;;;;;EASP,YAAA,eACT,QAAO;;;;UAQA;;;;;;;;;UAeA;;EA+BR,OAAO;;EAEP,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;;;;;;;;;;;;;;;EAiBP,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCR;;;;;;;;;;;;;;;;;wBAkBG,aAAa,UAAS,sBAA2B"}
+{"version":3,"file":"console.d.mts","names":[],"sources":["../src/console.ts"],"mappings":";;qBAgBa,yBAAyB;WAU3B;mBATO;;;;;;;EAQjB,YACU,eACT,QAAO;;;;UAQA;;;;;;;;;UAeA;;EA+BR,OAAO;;EAEP,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;;;;;;;;;;;;;;;EAiBP,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCR;;;;;;;;;;;;;;;;;wBAkBG,aAAa,UAAS,sBAA2B"}

package/dist/otel.cjs

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/otel.d.cts

@@ -0,0 +1,31 @@
+//#region src/otel.d.ts
+/** The instrumentation scope every bridged record carries. */
+export declare const OTEL_SCOPE = "@geekmidas/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.
+ */
+export declare function emitToOtel(line: string): void;
+/**
+ * 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 } });
+ * ```
+ */
+export declare function otelStreamWrite(line: string): string;
+//#endregion
+//# sourceMappingURL=otel.d.cts.map

package/dist/otel.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.d.cts","names":[],"sources":["../src/otel.ts"],"mappings":";;qBAyBa;;;;;;;;;;;;;wBAsDG,WAAW;;;;;;;;;;;;;wBA0CX,gBAAgB"}

package/dist/otel.d.mts

@@ -0,0 +1,31 @@
+//#region src/otel.d.ts
+/** The instrumentation scope every bridged record carries. */
+export declare const OTEL_SCOPE = "@geekmidas/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.
+ */
+export declare function emitToOtel(line: string): void;
+/**
+ * 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 } });
+ * ```
+ */
+export declare function otelStreamWrite(line: string): string;
+//#endregion
+//# sourceMappingURL=otel.d.mts.map

package/dist/otel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.d.mts","names":[],"sources":["../src/otel.ts"],"mappings":";;qBAyBa;;;;;;;;;;;;;wBAsDG,WAAW;;;;;;;;;;;;;wBA0CX,gBAAgB"}

package/dist/otel.mjs

@@ -0,0 +1,110 @@
+import { SeverityNumber, logs } from "@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: SeverityNumber.TRACE,
+	DEBUG: SeverityNumber.DEBUG,
+	INFO: SeverityNumber.INFO,
+	WARN: SeverityNumber.WARN,
+	ERROR: SeverityNumber.ERROR,
+	FATAL: SeverityNumber.FATAL
+};
+/** Pino's numeric levels, for a record whose level was not formatted. */
+function severityFromNumber(level) {
+	if (level >= 60) return SeverityNumber.FATAL;
+	if (level >= 50) return SeverityNumber.ERROR;
+	if (level >= 40) return SeverityNumber.WARN;
+	if (level >= 30) return SeverityNumber.INFO;
+	if (level >= 20) return SeverityNumber.DEBUG;
+	return SeverityNumber.TRACE;
+}
+const SEVERITY_TEXT = {
+	[SeverityNumber.TRACE]: "TRACE",
+	[SeverityNumber.DEBUG]: "DEBUG",
+	[SeverityNumber.INFO]: "INFO",
+	[SeverityNumber.WARN]: "WARN",
+	[SeverityNumber.ERROR]: "ERROR",
+	[SeverityNumber.FATAL]: "FATAL"
+};
+let cached;
+/** The bridge's logger from whichever provider is registered now. */
+function otelLogger() {
+	const provider = 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()] ?? 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
+export { OTEL_SCOPE, emitToOtel, otelStreamWrite };
+
+//# sourceMappingURL=otel.mjs.map

package/dist/otel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.mjs","names":[],"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,OAAO,eAAe;CACtB,OAAO,eAAe;CACtB,MAAM,eAAe;CACrB,MAAM,eAAe;CACrB,OAAO,eAAe;CACtB,OAAO,eAAe;AACvB;;AAGA,SAAS,mBAAmB,OAA+B;CAC1D,IAAI,SAAS,IAAI,OAAO,eAAe;CACvC,IAAI,SAAS,IAAI,OAAO,eAAe;CACvC,IAAI,SAAS,IAAI,OAAO,eAAe;CACvC,IAAI,SAAS,IAAI,OAAO,eAAe;CACvC,IAAI,SAAS,IAAI,OAAO,eAAe;CACvC,OAAO,eAAe;AACvB;AAEA,MAAM,gBAAyD;EAC7D,eAAe,QAAQ;EACvB,eAAe,QAAQ;EACvB,eAAe,OAAO;EACtB,eAAe,OAAO;EACtB,eAAe,QAAQ;EACvB,eAAe,QAAQ;AACzB;AAEA,IAAI;;AAGJ,SAAS,aAAqB;CAC7B,MAAM,WAAW,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,MAAM,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"}

package/dist/pino.cjs

@@ -1,16 +1,20 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_otel = require("./otel.cjs");
 const require_redact_paths = require("./redact-paths.cjs");
 let pino = require("pino");
 //#region src/pino.ts
 /**
 * Pino logger with built-in redaction support for sensitive data.
 *
+* Redaction is on by default: a logger that was never told about passwords
+* and tokens still masks them. `redact: false` is the explicit opt-out.
+*
 * @example
 * ```typescript
 * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';
 *
-* // Enable redaction with sensible defaults
-* const logger = createLogger({ redact: true });
+* // Redaction with sensible defaults — the same as `redact: true`
+* const logger = createLogger();
 *
 * // Sensitive data is automatically masked
 * logger.info({ password: 'secret123', user: 'john' }, 'Login');
@@ -32,14 +36,16 @@ let pino = require("pino");
 */
 /**
 * Resolves redaction configuration from options.
-* Returns undefined if redaction is disabled, or a pino-compatible redact config.
+* Returns undefined only when redaction is turned off with `false`; leaving it
+* unset is the same as `true`, so sensitive paths are masked unless someone
+* decides they should not be.
 *
 * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.
 * With resolution: 'override', only the custom paths are used.
 */
 function resolveRedactConfig(redact) {
-	if (redact === void 0 || redact === false) return;
-	if (redact === true) return require_redact_paths.DEFAULT_REDACT_PATHS;
+	if (redact === false) return;
+	if (redact === void 0 || redact === true) return require_redact_paths.DEFAULT_REDACT_PATHS;
 	if (Array.isArray(redact)) return [...require_redact_paths.DEFAULT_REDACT_PATHS, ...redact];
 	const { resolution = "merge", paths, censor, remove } = redact;
 	const config = { paths: resolution === "override" ? paths : [...require_redact_paths.DEFAULT_REDACT_PATHS, ...paths] };
@@ -55,27 +61,45 @@ function resolveRedactConfig(redact) {
 *
 * @example
 * ```typescript
-* // Basic logger
+* // Basic logger — sensitive paths are redacted by default
 * const logger = createLogger({ level: 'debug' });
 *
-* // With redaction enabled
-* const secureLogger = createLogger({ redact: true });
+* // Opt out of redaction
+* const rawLogger = createLogger({ redact: false });
 *
 * // Pretty printing in development
-* const devLogger = createLogger({ pretty: true, redact: true });
+* const devLogger = createLogger({ pretty: true });
 * ```
 */
 function createLogger(options = {}) {
-	const baseOptions = options?.pretty && process.NODE_ENV !== "production" ? { transport: {
+	const pretty = options?.pretty && process.env.NODE_ENV !== "production";
+	const baseOptions = pretty ? { transport: {
 		target: "pino-pretty",
 		options: { colorize: true }
 	} } : {};
 	const redact = resolveRedactConfig(options.redact);
-	return (0, pino.pino)({
+	const serializeError = (value) => {
+		const serialized = pino.stdSerializers.err(value);
+		if (!redact || serialized === value) return serialized;
+		return require_redact_paths.redactUrlCredentialsIn({ ...serialized });
+	};
+	const pinoOptions = {
 		...baseOptions,
 		...options.level && { level: options.level },
 		...redact && { redact },
+		serializers: {
+			err: serializeError,
+			error: serializeError
+		},
+		hooks: {
+			...redact && { logMethod(args, method) {
+				const redacted = args.map((arg) => typeof arg === "string" ? require_redact_paths.redactUrlCredentials(arg) : arg);
+				return method.apply(this, redacted);
+			} },
+			streamWrite: require_otel.otelStreamWrite
+		},
 		formatters: {
+			...redact && { log: (object) => require_redact_paths.redactUrlCredentialsIn(object) },
 			bindings() {
 				return { nodeVersion: process.version };
 			},
@@ -83,7 +107,8 @@ function createLogger(options = {}) {
 				return { level: label.toUpperCase() };
 			}
 		}
-	});
+	};
+	return options.destination && !pretty ? (0, pino.pino)(pinoOptions, options.destination) : (0, pino.pino)(pinoOptions);
 }
 //#endregion
 exports.DEFAULT_REDACT_PATHS = require_redact_paths.DEFAULT_REDACT_PATHS;

package/dist/pino.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"pino.cjs","names":["DEFAULT_REDACT_PATHS"],"sources":["../src/pino.ts"],"sourcesContent":["/**\n * Pino logger with built-in redaction support for sensitive data.\n *\n * @example\n * ```typescript\n * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';\n *\n * // Enable redaction with sensible defaults\n * const logger = createLogger({ redact: true });\n *\n * // Sensitive data is automatically masked\n * logger.info({ password: 'secret123', user: 'john' }, 'Login');\n * // Output: { password: '[Redacted]', user: 'john' } Login\n *\n * // Add custom paths (merged with defaults)\n * const logger2 = createLogger({ redact: ['user.ssn'] });\n *\n * // Override defaults for full control\n * const logger3 = createLogger({\n *   redact: {\n *     paths: ['onlyThis'],\n *     resolution: 'override',\n *   }\n * });\n * ```\n *\n * @module\n */\nimport { pino } from 'pino';\nimport { DEFAULT_REDACT_PATHS } from './redact-paths';\nimport type { CreateLoggerOptions, RedactOptions } from './types';\n\n// Re-export for backwards compatibility\nexport { DEFAULT_REDACT_PATHS } from './redact-paths';\n\n/**\n * Type for the resolved pino redact config (without our custom resolution field).\n */\ntype PinoRedactConfig =\n\t| string[]\n\t| {\n\t\t\tpaths: string[];\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\tremove?: boolean;\n\t  };\n\n/**\n * Resolves redaction configuration from options.\n * Returns undefined if redaction is disabled, or a pino-compatible redact config.\n *\n * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.\n * With resolution: 'override', only the custom paths are used.\n */\nfunction resolveRedactConfig(\n\tredact: boolean | RedactOptions | undefined,\n): PinoRedactConfig | undefined {\n\tif (redact === undefined || redact === false) {\n\t\treturn undefined;\n\t}\n\n\tif (redact === true) {\n\t\treturn DEFAULT_REDACT_PATHS;\n\t}\n\n\t// Array syntax - merge with defaults\n\tif (Array.isArray(redact)) {\n\t\treturn [...DEFAULT_REDACT_PATHS, ...redact];\n\t}\n\n\t// Object syntax - check resolution mode\n\tconst { resolution = 'merge', paths, censor, remove } = redact;\n\n\tconst resolvedPaths =\n\t\tresolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];\n\n\t// Return clean pino config without our resolution field\n\tconst config: PinoRedactConfig = { paths: resolvedPaths };\n\tif (censor !== undefined) config.censor = censor;\n\tif (remove !== undefined) config.remove = remove;\n\n\treturn config;\n}\n\n/**\n * Creates a pino logger instance with optional redaction support.\n *\n * @param options - Logger configuration options\n * @returns A configured pino logger instance\n *\n * @example\n * ```typescript\n * // Basic logger\n * const logger = createLogger({ level: 'debug' });\n *\n * // With redaction enabled\n * const secureLogger = createLogger({ redact: true });\n *\n * // Pretty printing in development\n * const devLogger = createLogger({ pretty: true, redact: true });\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}) {\n\t// @ts-expect-error\n\tconst pretty = options?.pretty && process.NODE_ENV !== 'production';\n\tconst baseOptions = pretty\n\t\t? {\n\t\t\t\ttransport: {\n\t\t\t\t\ttarget: 'pino-pretty',\n\t\t\t\t\toptions: { colorize: true },\n\t\t\t\t},\n\t\t\t}\n\t\t: {};\n\n\tconst redact = resolveRedactConfig(options.redact);\n\n\treturn pino({\n\t\t...baseOptions,\n\t\t...(options.level && { level: options.level }),\n\t\t...(redact && { redact }),\n\t\tformatters: {\n\t\t\tbindings() {\n\t\t\t\treturn { nodeVersion: process.version };\n\t\t\t},\n\t\t\tlevel: (label) => {\n\t\t\t\treturn { level: label.toUpperCase() };\n\t\t\t},\n\t\t},\n\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAS,oBACR,QAC+B;CAC/B,IAAI,WAAW,KAAA,KAAa,WAAW,OACtC;CAGD,IAAI,WAAW,MACd,OAAOA,qBAAAA;CAIR,IAAI,MAAM,QAAQ,MAAM,GACvB,OAAO,CAAC,GAAGA,qBAAAA,sBAAsB,GAAG,MAAM;CAI3C,MAAM,EAAE,aAAa,SAAS,OAAO,QAAQ,WAAW;CAMxD,MAAM,SAA2B,EAAE,OAHlC,eAAe,aAAa,QAAQ,CAAC,GAAGA,qBAAAA,sBAAsB,GAAG,KAAK,EAGf;CACxD,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAC1C,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAE1C,OAAO;AACR;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAa,UAA+B,CAAC,GAAG;CAG/D,MAAM,cADS,SAAS,UAAU,QAAQ,aAAa,eAEpD,EACA,WAAW;EACV,QAAQ;EACR,SAAS,EAAE,UAAU,KAAK;CAC3B,EACD,IACC,CAAC;CAEJ,MAAM,SAAS,oBAAoB,QAAQ,MAAM;CAEjD,QAAA,GAAO,KAAA,KAAA,CAAK;EACX,GAAG;EACH,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,MAAM;EAC5C,GAAI,UAAU,EAAE,OAAO;EACvB,YAAY;GACX,WAAW;IACV,OAAO,EAAE,aAAa,QAAQ,QAAQ;GACvC;GACA,QAAQ,UAAU;IACjB,OAAO,EAAE,OAAO,MAAM,YAAY,EAAE;GACrC;EACD;CACD,CAAC;AACF"}
+{"version":3,"file":"pino.cjs","names":["DEFAULT_REDACT_PATHS","stdSerializers","redactUrlCredentialsIn","redactUrlCredentials","otelStreamWrite"],"sources":["../src/pino.ts"],"sourcesContent":["/**\n * Pino logger with built-in redaction support for sensitive data.\n *\n * Redaction is on by default: a logger that was never told about passwords\n * and tokens still masks them. `redact: false` is the explicit opt-out.\n *\n * @example\n * ```typescript\n * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';\n *\n * // Redaction with sensible defaults — the same as `redact: true`\n * const logger = createLogger();\n *\n * // Sensitive data is automatically masked\n * logger.info({ password: 'secret123', user: 'john' }, 'Login');\n * // Output: { password: '[Redacted]', user: 'john' } Login\n *\n * // Add custom paths (merged with defaults)\n * const logger2 = createLogger({ redact: ['user.ssn'] });\n *\n * // Override defaults for full control\n * const logger3 = createLogger({\n *   redact: {\n *     paths: ['onlyThis'],\n *     resolution: 'override',\n *   }\n * });\n * ```\n *\n * @module\n */\nimport { type LogFn, type Logger, pino, stdSerializers } from 'pino';\nimport { otelStreamWrite } from './otel';\nimport {\n\tDEFAULT_REDACT_PATHS,\n\tredactUrlCredentials,\n\tredactUrlCredentialsIn,\n} from './redact-paths';\nimport type { CreateLoggerOptions, RedactOptions } from './types';\n\n// Re-export for backwards compatibility\nexport { DEFAULT_REDACT_PATHS } from './redact-paths';\n\n/**\n * Type for the resolved pino redact config (without our custom resolution field).\n */\ntype PinoRedactConfig =\n\t| string[]\n\t| {\n\t\t\tpaths: string[];\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\tremove?: boolean;\n\t  };\n\n/**\n * Resolves redaction configuration from options.\n * Returns undefined only when redaction is turned off with `false`; leaving it\n * unset is the same as `true`, so sensitive paths are masked unless someone\n * decides they should not be.\n *\n * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.\n * With resolution: 'override', only the custom paths are used.\n */\nfunction resolveRedactConfig(\n\tredact: boolean | RedactOptions | undefined,\n): PinoRedactConfig | undefined {\n\tif (redact === false) {\n\t\treturn undefined;\n\t}\n\n\tif (redact === undefined || redact === true) {\n\t\treturn DEFAULT_REDACT_PATHS;\n\t}\n\n\t// Array syntax - merge with defaults\n\tif (Array.isArray(redact)) {\n\t\treturn [...DEFAULT_REDACT_PATHS, ...redact];\n\t}\n\n\t// Object syntax - check resolution mode\n\tconst { resolution = 'merge', paths, censor, remove } = redact;\n\n\tconst resolvedPaths =\n\t\tresolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];\n\n\t// Return clean pino config without our resolution field\n\tconst config: PinoRedactConfig = { paths: resolvedPaths };\n\tif (censor !== undefined) config.censor = censor;\n\tif (remove !== undefined) config.remove = remove;\n\n\treturn config;\n}\n\n/**\n * Creates a pino logger instance with optional redaction support.\n *\n * @param options - Logger configuration options\n * @returns A configured pino logger instance\n *\n * @example\n * ```typescript\n * // Basic logger — sensitive paths are redacted by default\n * const logger = createLogger({ level: 'debug' });\n *\n * // Opt out of redaction\n * const rawLogger = createLogger({ redact: false });\n *\n * // Pretty printing in development\n * const devLogger = createLogger({ pretty: true });\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}) {\n\t// Pretty printing spawns a transport worker and writes for humans; in\n\t// production the output is for a log pipeline, so `pretty` is ignored there.\n\tconst pretty = options?.pretty && process.env.NODE_ENV !== 'production';\n\tconst baseOptions = pretty\n\t\t? {\n\t\t\t\ttransport: {\n\t\t\t\t\ttarget: 'pino-pretty',\n\t\t\t\t\toptions: { colorize: true },\n\t\t\t\t},\n\t\t\t}\n\t\t: {};\n\n\tconst redact = resolveRedactConfig(options.redact);\n\n\t// An Error is serialized only under a key pino has a serializer for — `err`\n\t// by default — and anything else is JSON.stringify'd, which an Error survives\n\t// as `{}`: no message, no stack. `logger.error({ error }, …)` is how most\n\t// code writes it, so `error` gets the same serializer as `err`.\n\t//\n\t// The serialized copy is a plain object, so URL credentials in the message\n\t// or the stack are masked like any other field; path redaction runs after\n\t// serializers, so `err.message` and `error.stack` are paths it can reach.\n\tconst serializeError = (value: unknown) => {\n\t\tconst serialized = stdSerializers.err(value as Error);\n\t\tif (!redact || serialized === value) return serialized;\n\t\treturn redactUrlCredentialsIn({ ...serialized });\n\t};\n\n\tconst pinoOptions = {\n\t\t...baseOptions,\n\t\t...(options.level && { level: options.level }),\n\t\t...(redact && { redact }),\n\t\tserializers: { err: serializeError, error: serializeError },\n\t\thooks: {\n\t\t\t// Redaction also masks the credentials of any URL, in any field or\n\t\t\t// in the message: `s3://KEY:SECRET@uploads` is logged with its\n\t\t\t// secret under a name no path list can predict.\n\t\t\t...(redact && {\n\t\t\t\tlogMethod(this: Logger, args: Parameters<LogFn>, method: LogFn) {\n\t\t\t\t\tconst redacted = args.map((arg) =>\n\t\t\t\t\t\ttypeof arg === 'string' ? redactUrlCredentials(arg) : arg,\n\t\t\t\t\t) as Parameters<LogFn>;\n\t\t\t\t\treturn method.apply(this, redacted);\n\t\t\t\t},\n\t\t\t}),\n\t\t\t// Each line, once redacted and serialized, also goes to\n\t\t\t// OpenTelemetry when a LoggerProvider is registered. On the calling\n\t\t\t// thread, before any transport, so the active span is the caller's.\n\t\t\tstreamWrite: otelStreamWrite,\n\t\t},\n\t\tformatters: {\n\t\t\t...(redact && {\n\t\t\t\tlog: (object: Record<string, unknown>) =>\n\t\t\t\t\tredactUrlCredentialsIn(object),\n\t\t\t}),\n\t\t\tbindings() {\n\t\t\t\treturn { nodeVersion: process.version };\n\t\t\t},\n\t\t\tlevel: (label: string) => {\n\t\t\t\treturn { level: label.toUpperCase() };\n\t\t\t},\n\t\t},\n\t};\n\n\t// A transport writes on its own worker, so a destination only applies when\n\t// the logger is not pretty-printing.\n\treturn options.destination && !pretty\n\t\t? pino(pinoOptions, options.destination)\n\t\t: pino(pinoOptions);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAS,oBACR,QAC+B;CAC/B,IAAI,WAAW,OACd;CAGD,IAAI,WAAW,KAAA,KAAa,WAAW,MACtC,OAAOA,qBAAAA;CAIR,IAAI,MAAM,QAAQ,MAAM,GACvB,OAAO,CAAC,GAAGA,qBAAAA,sBAAsB,GAAG,MAAM;CAI3C,MAAM,EAAE,aAAa,SAAS,OAAO,QAAQ,WAAW;CAMxD,MAAM,SAA2B,EAAE,OAHlC,eAAe,aAAa,QAAQ,CAAC,GAAGA,qBAAAA,sBAAsB,GAAG,KAAK,EAGf;CACxD,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAC1C,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAE1C,OAAO;AACR;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAa,UAA+B,CAAC,GAAG;CAG/D,MAAM,SAAS,SAAS,UAAU,QAAQ,IAAI,aAAa;CAC3D,MAAM,cAAc,SACjB,EACA,WAAW;EACV,QAAQ;EACR,SAAS,EAAE,UAAU,KAAK;CAC3B,EACD,IACC,CAAC;CAEJ,MAAM,SAAS,oBAAoB,QAAQ,MAAM;CAUjD,MAAM,kBAAkB,UAAmB;EAC1C,MAAM,aAAaC,KAAAA,eAAe,IAAI,KAAc;EACpD,IAAI,CAAC,UAAU,eAAe,OAAO,OAAO;EAC5C,OAAOC,qBAAAA,uBAAuB,EAAE,GAAG,WAAW,CAAC;CAChD;CAEA,MAAM,cAAc;EACnB,GAAG;EACH,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,MAAM;EAC5C,GAAI,UAAU,EAAE,OAAO;EACvB,aAAa;GAAE,KAAK;GAAgB,OAAO;EAAe;EAC1D,OAAO;GAIN,GAAI,UAAU,EACb,UAAwB,MAAyB,QAAe;IAC/D,MAAM,WAAW,KAAK,KAAK,QAC1B,OAAO,QAAQ,WAAWC,qBAAAA,qBAAqB,GAAG,IAAI,GACvD;IACA,OAAO,OAAO,MAAM,MAAM,QAAQ;GACnC,EACD;GAIA,aAAaC,aAAAA;EACd;EACA,YAAY;GACX,GAAI,UAAU,EACb,MAAM,WACLF,qBAAAA,uBAAuB,MAAM,EAC/B;GACA,WAAW;IACV,OAAO,EAAE,aAAa,QAAQ,QAAQ;GACvC;GACA,QAAQ,UAAkB;IACzB,OAAO,EAAE,OAAO,MAAM,YAAY,EAAE;GACrC;EACD;CACD;CAIA,OAAO,QAAQ,eAAe,CAAC,UAAA,GAC5B,KAAA,KAAA,CAAK,aAAa,QAAQ,WAAW,KAAA,GACrC,KAAA,KAAA,CAAK,WAAW;AACpB"}

package/dist/pino.d.cts

@@ -1,5 +1,6 @@
 import { CreateLoggerOptions } from "./types.cjs";
 import { DEFAULT_REDACT_PATHS } from "./redact-paths.cjs";
+import { Logger } from "pino";
 //#region src/pino.d.ts
 /**
  * Creates a pino logger instance with optional redaction support.
@@ -9,17 +10,17 @@ import { DEFAULT_REDACT_PATHS } from "./redact-paths.cjs";
  *
  * @example
  * ```typescript
- * // Basic logger
+ * // Basic logger — sensitive paths are redacted by default
  * const logger = createLogger({ level: 'debug' });
  *
- * // With redaction enabled
- * const secureLogger = createLogger({ redact: true });
+ * // Opt out of redaction
+ * const rawLogger = createLogger({ redact: false });
  *
  * // Pretty printing in development
- * const devLogger = createLogger({ pretty: true, redact: true });
+ * const devLogger = createLogger({ pretty: true });
  * ```
  */
-export declare function createLogger(options?: CreateLoggerOptions): import("pino").Logger<never, boolean>;
+export declare function createLogger(options?: CreateLoggerOptions): Logger<never, boolean>;
 //#endregion
 export { DEFAULT_REDACT_PATHS };
 //# sourceMappingURL=pino.d.cts.map

package/dist/pino.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"pino.d.cts","names":[],"sources":["../src/pino.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBAqGgB,aAAa,UAAS,qCAAwB"}
+{"version":3,"file":"pino.d.cts","names":[],"sources":["../src/pino.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;wBA+GgB,aAAa,UAAS,sBAAwB"}

package/dist/pino.d.mts

@@ -1,5 +1,6 @@
 import { CreateLoggerOptions } from "./types.mjs";
 import { DEFAULT_REDACT_PATHS } from "./redact-paths.mjs";
+import { Logger } from "pino";
 //#region src/pino.d.ts
 /**
  * Creates a pino logger instance with optional redaction support.
@@ -9,17 +10,17 @@ import { DEFAULT_REDACT_PATHS } from "./redact-paths.mjs";
  *
  * @example
  * ```typescript
- * // Basic logger
+ * // Basic logger — sensitive paths are redacted by default
  * const logger = createLogger({ level: 'debug' });
  *
- * // With redaction enabled
- * const secureLogger = createLogger({ redact: true });
+ * // Opt out of redaction
+ * const rawLogger = createLogger({ redact: false });
  *
  * // Pretty printing in development
- * const devLogger = createLogger({ pretty: true, redact: true });
+ * const devLogger = createLogger({ pretty: true });
  * ```
  */
-export declare function createLogger(options?: CreateLoggerOptions): import("pino").Logger<never, boolean>;
+export declare function createLogger(options?: CreateLoggerOptions): Logger<never, boolean>;
 //#endregion
 export { DEFAULT_REDACT_PATHS };
 //# sourceMappingURL=pino.d.mts.map

package/dist/pino.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pino.d.mts","names":[],"sources":["../src/pino.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBAqGgB,aAAa,UAAS,qCAAwB"}
+{"version":3,"file":"pino.d.mts","names":[],"sources":["../src/pino.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;wBA+GgB,aAAa,UAAS,sBAAwB"}

package/dist/pino.mjs

@@ -1,15 +1,19 @@
-import { DEFAULT_REDACT_PATHS } from "./redact-paths.mjs";
-import { pino } from "pino";
+import { otelStreamWrite } from "./otel.mjs";
+import { DEFAULT_REDACT_PATHS, redactUrlCredentials, redactUrlCredentialsIn } from "./redact-paths.mjs";
+import { pino, stdSerializers } from "pino";
 //#region src/pino.ts
 /**
 * Pino logger with built-in redaction support for sensitive data.
 *
+* Redaction is on by default: a logger that was never told about passwords
+* and tokens still masks them. `redact: false` is the explicit opt-out.
+*
 * @example
 * ```typescript
 * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';
 *
-* // Enable redaction with sensible defaults
-* const logger = createLogger({ redact: true });
+* // Redaction with sensible defaults — the same as `redact: true`
+* const logger = createLogger();
 *
 * // Sensitive data is automatically masked
 * logger.info({ password: 'secret123', user: 'john' }, 'Login');
@@ -31,14 +35,16 @@ import { pino } from "pino";
 */
 /**
 * Resolves redaction configuration from options.
-* Returns undefined if redaction is disabled, or a pino-compatible redact config.
+* Returns undefined only when redaction is turned off with `false`; leaving it
+* unset is the same as `true`, so sensitive paths are masked unless someone
+* decides they should not be.
 *
 * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.
 * With resolution: 'override', only the custom paths are used.
 */
 function resolveRedactConfig(redact) {
-	if (redact === void 0 || redact === false) return;
-	if (redact === true) return DEFAULT_REDACT_PATHS;
+	if (redact === false) return;
+	if (redact === void 0 || redact === true) return DEFAULT_REDACT_PATHS;
 	if (Array.isArray(redact)) return [...DEFAULT_REDACT_PATHS, ...redact];
 	const { resolution = "merge", paths, censor, remove } = redact;
 	const config = { paths: resolution === "override" ? paths : [...DEFAULT_REDACT_PATHS, ...paths] };
@@ -54,27 +60,45 @@ function resolveRedactConfig(redact) {
 *
 * @example
 * ```typescript
-* // Basic logger
+* // Basic logger — sensitive paths are redacted by default
 * const logger = createLogger({ level: 'debug' });
 *
-* // With redaction enabled
-* const secureLogger = createLogger({ redact: true });
+* // Opt out of redaction
+* const rawLogger = createLogger({ redact: false });
 *
 * // Pretty printing in development
-* const devLogger = createLogger({ pretty: true, redact: true });
+* const devLogger = createLogger({ pretty: true });
 * ```
 */
 function createLogger(options = {}) {
-	const baseOptions = options?.pretty && process.NODE_ENV !== "production" ? { transport: {
+	const pretty = options?.pretty && process.env.NODE_ENV !== "production";
+	const baseOptions = pretty ? { transport: {
 		target: "pino-pretty",
 		options: { colorize: true }
 	} } : {};
 	const redact = resolveRedactConfig(options.redact);
-	return pino({
+	const serializeError = (value) => {
+		const serialized = stdSerializers.err(value);
+		if (!redact || serialized === value) return serialized;
+		return redactUrlCredentialsIn({ ...serialized });
+	};
+	const pinoOptions = {
 		...baseOptions,
 		...options.level && { level: options.level },
 		...redact && { redact },
+		serializers: {
+			err: serializeError,
+			error: serializeError
+		},
+		hooks: {
+			...redact && { logMethod(args, method) {
+				const redacted = args.map((arg) => typeof arg === "string" ? redactUrlCredentials(arg) : arg);
+				return method.apply(this, redacted);
+			} },
+			streamWrite: otelStreamWrite
+		},
 		formatters: {
+			...redact && { log: (object) => redactUrlCredentialsIn(object) },
 			bindings() {
 				return { nodeVersion: process.version };
 			},
@@ -82,7 +106,8 @@ function createLogger(options = {}) {
 				return { level: label.toUpperCase() };
 			}
 		}
-	});
+	};
+	return options.destination && !pretty ? pino(pinoOptions, options.destination) : pino(pinoOptions);
 }
 //#endregion
 export { DEFAULT_REDACT_PATHS, createLogger };

package/dist/pino.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pino.mjs","names":[],"sources":["../src/pino.ts"],"sourcesContent":["/**\n * Pino logger with built-in redaction support for sensitive data.\n *\n * @example\n * ```typescript\n * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';\n *\n * // Enable redaction with sensible defaults\n * const logger = createLogger({ redact: true });\n *\n * // Sensitive data is automatically masked\n * logger.info({ password: 'secret123', user: 'john' }, 'Login');\n * // Output: { password: '[Redacted]', user: 'john' } Login\n *\n * // Add custom paths (merged with defaults)\n * const logger2 = createLogger({ redact: ['user.ssn'] });\n *\n * // Override defaults for full control\n * const logger3 = createLogger({\n *   redact: {\n *     paths: ['onlyThis'],\n *     resolution: 'override',\n *   }\n * });\n * ```\n *\n * @module\n */\nimport { pino } from 'pino';\nimport { DEFAULT_REDACT_PATHS } from './redact-paths';\nimport type { CreateLoggerOptions, RedactOptions } from './types';\n\n// Re-export for backwards compatibility\nexport { DEFAULT_REDACT_PATHS } from './redact-paths';\n\n/**\n * Type for the resolved pino redact config (without our custom resolution field).\n */\ntype PinoRedactConfig =\n\t| string[]\n\t| {\n\t\t\tpaths: string[];\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\tremove?: boolean;\n\t  };\n\n/**\n * Resolves redaction configuration from options.\n * Returns undefined if redaction is disabled, or a pino-compatible redact config.\n *\n * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.\n * With resolution: 'override', only the custom paths are used.\n */\nfunction resolveRedactConfig(\n\tredact: boolean | RedactOptions | undefined,\n): PinoRedactConfig | undefined {\n\tif (redact === undefined || redact === false) {\n\t\treturn undefined;\n\t}\n\n\tif (redact === true) {\n\t\treturn DEFAULT_REDACT_PATHS;\n\t}\n\n\t// Array syntax - merge with defaults\n\tif (Array.isArray(redact)) {\n\t\treturn [...DEFAULT_REDACT_PATHS, ...redact];\n\t}\n\n\t// Object syntax - check resolution mode\n\tconst { resolution = 'merge', paths, censor, remove } = redact;\n\n\tconst resolvedPaths =\n\t\tresolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];\n\n\t// Return clean pino config without our resolution field\n\tconst config: PinoRedactConfig = { paths: resolvedPaths };\n\tif (censor !== undefined) config.censor = censor;\n\tif (remove !== undefined) config.remove = remove;\n\n\treturn config;\n}\n\n/**\n * Creates a pino logger instance with optional redaction support.\n *\n * @param options - Logger configuration options\n * @returns A configured pino logger instance\n *\n * @example\n * ```typescript\n * // Basic logger\n * const logger = createLogger({ level: 'debug' });\n *\n * // With redaction enabled\n * const secureLogger = createLogger({ redact: true });\n *\n * // Pretty printing in development\n * const devLogger = createLogger({ pretty: true, redact: true });\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}) {\n\t// @ts-expect-error\n\tconst pretty = options?.pretty && process.NODE_ENV !== 'production';\n\tconst baseOptions = pretty\n\t\t? {\n\t\t\t\ttransport: {\n\t\t\t\t\ttarget: 'pino-pretty',\n\t\t\t\t\toptions: { colorize: true },\n\t\t\t\t},\n\t\t\t}\n\t\t: {};\n\n\tconst redact = resolveRedactConfig(options.redact);\n\n\treturn pino({\n\t\t...baseOptions,\n\t\t...(options.level && { level: options.level }),\n\t\t...(redact && { redact }),\n\t\tformatters: {\n\t\t\tbindings() {\n\t\t\t\treturn { nodeVersion: process.version };\n\t\t\t},\n\t\t\tlevel: (label) => {\n\t\t\t\treturn { level: label.toUpperCase() };\n\t\t\t},\n\t\t},\n\t});\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAS,oBACR,QAC+B;CAC/B,IAAI,WAAW,KAAA,KAAa,WAAW,OACtC;CAGD,IAAI,WAAW,MACd,OAAO;CAIR,IAAI,MAAM,QAAQ,MAAM,GACvB,OAAO,CAAC,GAAG,sBAAsB,GAAG,MAAM;CAI3C,MAAM,EAAE,aAAa,SAAS,OAAO,QAAQ,WAAW;CAMxD,MAAM,SAA2B,EAAE,OAHlC,eAAe,aAAa,QAAQ,CAAC,GAAG,sBAAsB,GAAG,KAAK,EAGf;CACxD,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAC1C,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAE1C,OAAO;AACR;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAa,UAA+B,CAAC,GAAG;CAG/D,MAAM,cADS,SAAS,UAAU,QAAQ,aAAa,eAEpD,EACA,WAAW;EACV,QAAQ;EACR,SAAS,EAAE,UAAU,KAAK;CAC3B,EACD,IACC,CAAC;CAEJ,MAAM,SAAS,oBAAoB,QAAQ,MAAM;CAEjD,OAAO,KAAK;EACX,GAAG;EACH,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,MAAM;EAC5C,GAAI,UAAU,EAAE,OAAO;EACvB,YAAY;GACX,WAAW;IACV,OAAO,EAAE,aAAa,QAAQ,QAAQ;GACvC;GACA,QAAQ,UAAU;IACjB,OAAO,EAAE,OAAO,MAAM,YAAY,EAAE;GACrC;EACD;CACD,CAAC;AACF"}
+{"version":3,"file":"pino.mjs","names":[],"sources":["../src/pino.ts"],"sourcesContent":["/**\n * Pino logger with built-in redaction support for sensitive data.\n *\n * Redaction is on by default: a logger that was never told about passwords\n * and tokens still masks them. `redact: false` is the explicit opt-out.\n *\n * @example\n * ```typescript\n * import { createLogger, DEFAULT_REDACT_PATHS } from '@geekmidas/logger/pino';\n *\n * // Redaction with sensible defaults — the same as `redact: true`\n * const logger = createLogger();\n *\n * // Sensitive data is automatically masked\n * logger.info({ password: 'secret123', user: 'john' }, 'Login');\n * // Output: { password: '[Redacted]', user: 'john' } Login\n *\n * // Add custom paths (merged with defaults)\n * const logger2 = createLogger({ redact: ['user.ssn'] });\n *\n * // Override defaults for full control\n * const logger3 = createLogger({\n *   redact: {\n *     paths: ['onlyThis'],\n *     resolution: 'override',\n *   }\n * });\n * ```\n *\n * @module\n */\nimport { type LogFn, type Logger, pino, stdSerializers } from 'pino';\nimport { otelStreamWrite } from './otel';\nimport {\n\tDEFAULT_REDACT_PATHS,\n\tredactUrlCredentials,\n\tredactUrlCredentialsIn,\n} from './redact-paths';\nimport type { CreateLoggerOptions, RedactOptions } from './types';\n\n// Re-export for backwards compatibility\nexport { DEFAULT_REDACT_PATHS } from './redact-paths';\n\n/**\n * Type for the resolved pino redact config (without our custom resolution field).\n */\ntype PinoRedactConfig =\n\t| string[]\n\t| {\n\t\t\tpaths: string[];\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\tremove?: boolean;\n\t  };\n\n/**\n * Resolves redaction configuration from options.\n * Returns undefined only when redaction is turned off with `false`; leaving it\n * unset is the same as `true`, so sensitive paths are masked unless someone\n * decides they should not be.\n *\n * By default (resolution: 'merge'), custom paths are merged with DEFAULT_REDACT_PATHS.\n * With resolution: 'override', only the custom paths are used.\n */\nfunction resolveRedactConfig(\n\tredact: boolean | RedactOptions | undefined,\n): PinoRedactConfig | undefined {\n\tif (redact === false) {\n\t\treturn undefined;\n\t}\n\n\tif (redact === undefined || redact === true) {\n\t\treturn DEFAULT_REDACT_PATHS;\n\t}\n\n\t// Array syntax - merge with defaults\n\tif (Array.isArray(redact)) {\n\t\treturn [...DEFAULT_REDACT_PATHS, ...redact];\n\t}\n\n\t// Object syntax - check resolution mode\n\tconst { resolution = 'merge', paths, censor, remove } = redact;\n\n\tconst resolvedPaths =\n\t\tresolution === 'override' ? paths : [...DEFAULT_REDACT_PATHS, ...paths];\n\n\t// Return clean pino config without our resolution field\n\tconst config: PinoRedactConfig = { paths: resolvedPaths };\n\tif (censor !== undefined) config.censor = censor;\n\tif (remove !== undefined) config.remove = remove;\n\n\treturn config;\n}\n\n/**\n * Creates a pino logger instance with optional redaction support.\n *\n * @param options - Logger configuration options\n * @returns A configured pino logger instance\n *\n * @example\n * ```typescript\n * // Basic logger — sensitive paths are redacted by default\n * const logger = createLogger({ level: 'debug' });\n *\n * // Opt out of redaction\n * const rawLogger = createLogger({ redact: false });\n *\n * // Pretty printing in development\n * const devLogger = createLogger({ pretty: true });\n * ```\n */\nexport function createLogger(options: CreateLoggerOptions = {}) {\n\t// Pretty printing spawns a transport worker and writes for humans; in\n\t// production the output is for a log pipeline, so `pretty` is ignored there.\n\tconst pretty = options?.pretty && process.env.NODE_ENV !== 'production';\n\tconst baseOptions = pretty\n\t\t? {\n\t\t\t\ttransport: {\n\t\t\t\t\ttarget: 'pino-pretty',\n\t\t\t\t\toptions: { colorize: true },\n\t\t\t\t},\n\t\t\t}\n\t\t: {};\n\n\tconst redact = resolveRedactConfig(options.redact);\n\n\t// An Error is serialized only under a key pino has a serializer for — `err`\n\t// by default — and anything else is JSON.stringify'd, which an Error survives\n\t// as `{}`: no message, no stack. `logger.error({ error }, …)` is how most\n\t// code writes it, so `error` gets the same serializer as `err`.\n\t//\n\t// The serialized copy is a plain object, so URL credentials in the message\n\t// or the stack are masked like any other field; path redaction runs after\n\t// serializers, so `err.message` and `error.stack` are paths it can reach.\n\tconst serializeError = (value: unknown) => {\n\t\tconst serialized = stdSerializers.err(value as Error);\n\t\tif (!redact || serialized === value) return serialized;\n\t\treturn redactUrlCredentialsIn({ ...serialized });\n\t};\n\n\tconst pinoOptions = {\n\t\t...baseOptions,\n\t\t...(options.level && { level: options.level }),\n\t\t...(redact && { redact }),\n\t\tserializers: { err: serializeError, error: serializeError },\n\t\thooks: {\n\t\t\t// Redaction also masks the credentials of any URL, in any field or\n\t\t\t// in the message: `s3://KEY:SECRET@uploads` is logged with its\n\t\t\t// secret under a name no path list can predict.\n\t\t\t...(redact && {\n\t\t\t\tlogMethod(this: Logger, args: Parameters<LogFn>, method: LogFn) {\n\t\t\t\t\tconst redacted = args.map((arg) =>\n\t\t\t\t\t\ttypeof arg === 'string' ? redactUrlCredentials(arg) : arg,\n\t\t\t\t\t) as Parameters<LogFn>;\n\t\t\t\t\treturn method.apply(this, redacted);\n\t\t\t\t},\n\t\t\t}),\n\t\t\t// Each line, once redacted and serialized, also goes to\n\t\t\t// OpenTelemetry when a LoggerProvider is registered. On the calling\n\t\t\t// thread, before any transport, so the active span is the caller's.\n\t\t\tstreamWrite: otelStreamWrite,\n\t\t},\n\t\tformatters: {\n\t\t\t...(redact && {\n\t\t\t\tlog: (object: Record<string, unknown>) =>\n\t\t\t\t\tredactUrlCredentialsIn(object),\n\t\t\t}),\n\t\t\tbindings() {\n\t\t\t\treturn { nodeVersion: process.version };\n\t\t\t},\n\t\t\tlevel: (label: string) => {\n\t\t\t\treturn { level: label.toUpperCase() };\n\t\t\t},\n\t\t},\n\t};\n\n\t// A transport writes on its own worker, so a destination only applies when\n\t// the logger is not pretty-printing.\n\treturn options.destination && !pretty\n\t\t? pino(pinoOptions, options.destination)\n\t\t: pino(pinoOptions);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,SAAS,oBACR,QAC+B;CAC/B,IAAI,WAAW,OACd;CAGD,IAAI,WAAW,KAAA,KAAa,WAAW,MACtC,OAAO;CAIR,IAAI,MAAM,QAAQ,MAAM,GACvB,OAAO,CAAC,GAAG,sBAAsB,GAAG,MAAM;CAI3C,MAAM,EAAE,aAAa,SAAS,OAAO,QAAQ,WAAW;CAMxD,MAAM,SAA2B,EAAE,OAHlC,eAAe,aAAa,QAAQ,CAAC,GAAG,sBAAsB,GAAG,KAAK,EAGf;CACxD,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAC1C,IAAI,WAAW,KAAA,GAAW,OAAO,SAAS;CAE1C,OAAO;AACR;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,aAAa,UAA+B,CAAC,GAAG;CAG/D,MAAM,SAAS,SAAS,UAAU,QAAQ,IAAI,aAAa;CAC3D,MAAM,cAAc,SACjB,EACA,WAAW;EACV,QAAQ;EACR,SAAS,EAAE,UAAU,KAAK;CAC3B,EACD,IACC,CAAC;CAEJ,MAAM,SAAS,oBAAoB,QAAQ,MAAM;CAUjD,MAAM,kBAAkB,UAAmB;EAC1C,MAAM,aAAa,eAAe,IAAI,KAAc;EACpD,IAAI,CAAC,UAAU,eAAe,OAAO,OAAO;EAC5C,OAAO,uBAAuB,EAAE,GAAG,WAAW,CAAC;CAChD;CAEA,MAAM,cAAc;EACnB,GAAG;EACH,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,MAAM;EAC5C,GAAI,UAAU,EAAE,OAAO;EACvB,aAAa;GAAE,KAAK;GAAgB,OAAO;EAAe;EAC1D,OAAO;GAIN,GAAI,UAAU,EACb,UAAwB,MAAyB,QAAe;IAC/D,MAAM,WAAW,KAAK,KAAK,QAC1B,OAAO,QAAQ,WAAW,qBAAqB,GAAG,IAAI,GACvD;IACA,OAAO,OAAO,MAAM,MAAM,QAAQ;GACnC,EACD;GAIA,aAAa;EACd;EACA,YAAY;GACX,GAAI,UAAU,EACb,MAAM,WACL,uBAAuB,MAAM,EAC/B;GACA,WAAW;IACV,OAAO,EAAE,aAAa,QAAQ,QAAQ;GACvC;GACA,QAAQ,UAAkB;IACzB,OAAO,EAAE,OAAO,MAAM,YAAY,EAAE;GACrC;EACD;CACD;CAIA,OAAO,QAAQ,eAAe,CAAC,SAC5B,KAAK,aAAa,QAAQ,WAAW,IACrC,KAAK,WAAW;AACpB"}

package/dist/redact-paths.cjs

@@ -62,7 +62,56 @@ const DEFAULT_REDACT_PATHS = [
 	"databaseUrl",
 	"database_url"
 ];
+/**
+* `scheme://user:password@` — the userinfo of a URL that carries a secret.
+* A user with no password (`ssh://git@host`) names nobody's secret and is left
+* alone.
+*/
+const URL_CREDENTIALS = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/?#@:]*:[^\s/?#@]*@/gi;
+/**
+* Replace the credentials of every URL in `text` with `REDACTED`, so
+* `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.
+*
+* Path redaction cannot catch these: a URL turns up under any field name —
+* `url`, `origin`, `endpoint` — or inside a message, and blanking every such
+* field would hide the half of it that is useful.
+*/
+function redactUrlCredentials(text) {
+	return text.replace(URL_CREDENTIALS, "$1REDACTED@");
+}
+/** Deep enough for a log object; past it, values are logged as they are. */
+const MAX_DEPTH = 6;
+/**
+* A copy of `value` with {@link redactUrlCredentials} applied to every string
+* in it. Objects and arrays without such a string are returned as they were.
+*/
+function redactUrlCredentialsIn(value, depth = 0) {
+	if (typeof value === "string") return redactUrlCredentials(value);
+	if (depth >= MAX_DEPTH || value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((item) => {
+			const redacted = redactUrlCredentialsIn(item, depth + 1);
+			if (redacted !== item) changed = true;
+			return redacted;
+		});
+		return changed ? next : value;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return value;
+	let next;
+	for (const [key, item] of Object.entries(value)) {
+		const redacted = redactUrlCredentialsIn(item, depth + 1);
+		if (redacted !== item) {
+			next ??= { ...value };
+			next[key] = redacted;
+		}
+	}
+	return next ?? value;
+}
 //#endregion
 exports.DEFAULT_REDACT_PATHS = DEFAULT_REDACT_PATHS;
+exports.redactUrlCredentials = redactUrlCredentials;
+exports.redactUrlCredentialsIn = redactUrlCredentialsIn;
 
 //# sourceMappingURL=redact-paths.cjs.map

package/dist/redact-paths.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"redact-paths.cjs","names":[],"sources":["../src/redact-paths.ts"],"sourcesContent":["/**\n * Default sensitive field paths for redaction.\n *\n * These paths are automatically used when `redact: true` is set,\n * and merged with custom paths unless `resolution: 'override'` is specified.\n *\n * Includes:\n * - Authentication: password, token, apiKey, authorization, credentials\n * - Headers: authorization, cookie, x-api-key, x-auth-token\n * - Personal data: ssn, creditCard, cvv, pin\n * - Secrets: secret, connectionString, databaseUrl\n * - Wildcards: *.password, *.secret, *.token (catches nested fields)\n */\nexport const DEFAULT_REDACT_PATHS: string[] = [\n\t// Authentication & authorization\n\t'password',\n\t'pass',\n\t'passwd',\n\t'secret',\n\t'token',\n\t'accessToken',\n\t'refreshToken',\n\t'idToken',\n\t'apiKey',\n\t'api_key',\n\t'apikey',\n\t'auth',\n\t'authorization',\n\t'credential',\n\t'credentials',\n\n\t// Common nested patterns (headers, body, etc.)\n\t'*.password',\n\t'*.secret',\n\t'*.token',\n\t'*.apiKey',\n\t'*.api_key',\n\t'*.authorization',\n\t'*.accessToken',\n\t'*.refreshToken',\n\n\t// HTTP headers (case variations)\n\t'headers.authorization',\n\t'headers.Authorization',\n\t'headers[\"authorization\"]',\n\t'headers[\"Authorization\"]',\n\t'headers.cookie',\n\t'headers.Cookie',\n\t'headers[\"x-api-key\"]',\n\t'headers[\"X-Api-Key\"]',\n\t'headers[\"x-auth-token\"]',\n\t'headers[\"X-Auth-Token\"]',\n\n\t// Common sensitive data fields\n\t'ssn',\n\t'socialSecurityNumber',\n\t'social_security_number',\n\t'creditCard',\n\t'credit_card',\n\t'cardNumber',\n\t'card_number',\n\t'cvv',\n\t'cvc',\n\t'pin',\n\n\t// Database & connection strings\n\t'connectionString',\n\t'connection_string',\n\t'databaseUrl',\n\t'database_url',\n];\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,uBAAiC;CAE7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;AACD"}
+{"version":3,"file":"redact-paths.cjs","names":[],"sources":["../src/redact-paths.ts"],"sourcesContent":["/**\n * Default sensitive field paths for redaction.\n *\n * These paths are automatically used when `redact: true` is set,\n * and merged with custom paths unless `resolution: 'override'` is specified.\n *\n * Includes:\n * - Authentication: password, token, apiKey, authorization, credentials\n * - Headers: authorization, cookie, x-api-key, x-auth-token\n * - Personal data: ssn, creditCard, cvv, pin\n * - Secrets: secret, connectionString, databaseUrl\n * - Wildcards: *.password, *.secret, *.token (catches nested fields)\n */\nexport const DEFAULT_REDACT_PATHS: string[] = [\n\t// Authentication & authorization\n\t'password',\n\t'pass',\n\t'passwd',\n\t'secret',\n\t'token',\n\t'accessToken',\n\t'refreshToken',\n\t'idToken',\n\t'apiKey',\n\t'api_key',\n\t'apikey',\n\t'auth',\n\t'authorization',\n\t'credential',\n\t'credentials',\n\n\t// Common nested patterns (headers, body, etc.)\n\t'*.password',\n\t'*.secret',\n\t'*.token',\n\t'*.apiKey',\n\t'*.api_key',\n\t'*.authorization',\n\t'*.accessToken',\n\t'*.refreshToken',\n\n\t// HTTP headers (case variations)\n\t'headers.authorization',\n\t'headers.Authorization',\n\t'headers[\"authorization\"]',\n\t'headers[\"Authorization\"]',\n\t'headers.cookie',\n\t'headers.Cookie',\n\t'headers[\"x-api-key\"]',\n\t'headers[\"X-Api-Key\"]',\n\t'headers[\"x-auth-token\"]',\n\t'headers[\"X-Auth-Token\"]',\n\n\t// Common sensitive data fields\n\t'ssn',\n\t'socialSecurityNumber',\n\t'social_security_number',\n\t'creditCard',\n\t'credit_card',\n\t'cardNumber',\n\t'card_number',\n\t'cvv',\n\t'cvc',\n\t'pin',\n\n\t// Database & connection strings\n\t'connectionString',\n\t'connection_string',\n\t'databaseUrl',\n\t'database_url',\n];\n\n/**\n * `scheme://user:password@` — the userinfo of a URL that carries a secret.\n * A user with no password (`ssh://git@host`) names nobody's secret and is left\n * alone.\n */\nconst URL_CREDENTIALS = /\\b([a-z][a-z0-9+.-]*:\\/\\/)[^\\s/?#@:]*:[^\\s/?#@]*@/gi;\n\n/**\n * Replace the credentials of every URL in `text` with `REDACTED`, so\n * `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.\n *\n * Path redaction cannot catch these: a URL turns up under any field name —\n * `url`, `origin`, `endpoint` — or inside a message, and blanking every such\n * field would hide the half of it that is useful.\n */\nexport function redactUrlCredentials(text: string): string {\n\treturn text.replace(URL_CREDENTIALS, '$1REDACTED@');\n}\n\n/** Deep enough for a log object; past it, values are logged as they are. */\nconst MAX_DEPTH = 6;\n\n/**\n * A copy of `value` with {@link redactUrlCredentials} applied to every string\n * in it. Objects and arrays without such a string are returned as they were.\n */\nexport function redactUrlCredentialsIn<T>(value: T, depth = 0): T {\n\tif (typeof value === 'string') {\n\t\treturn redactUrlCredentials(value) as T;\n\t}\n\tif (depth >= MAX_DEPTH || value === null || typeof value !== 'object') {\n\t\treturn value;\n\t}\n\tif (Array.isArray(value)) {\n\t\tlet changed = false;\n\t\tconst next = value.map((item) => {\n\t\t\tconst redacted = redactUrlCredentialsIn(item, depth + 1);\n\t\t\tif (redacted !== item) changed = true;\n\t\t\treturn redacted;\n\t\t});\n\t\treturn (changed ? next : value) as T;\n\t}\n\tconst proto = Object.getPrototypeOf(value);\n\tif (proto !== Object.prototype && proto !== null) return value;\n\n\tlet next: Record<string, unknown> | undefined;\n\tfor (const [key, item] of Object.entries(value)) {\n\t\tconst redacted = redactUrlCredentialsIn(item, depth + 1);\n\t\tif (redacted !== item) {\n\t\t\tnext ??= { ...(value as Record<string, unknown>) };\n\t\t\tnext[key] = redacted;\n\t\t}\n\t}\n\treturn (next ?? value) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAaA,MAAa,uBAAiC;CAE7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;AACD;;;;;;AAOA,MAAM,kBAAkB;;;;;;;;;AAUxB,SAAgB,qBAAqB,MAAsB;CAC1D,OAAO,KAAK,QAAQ,iBAAiB,aAAa;AACnD;;AAGA,MAAM,YAAY;;;;;AAMlB,SAAgB,uBAA0B,OAAU,QAAQ,GAAM;CACjE,IAAI,OAAO,UAAU,UACpB,OAAO,qBAAqB,KAAK;CAElC,IAAI,SAAS,aAAa,UAAU,QAAQ,OAAO,UAAU,UAC5D,OAAO;CAER,IAAI,MAAM,QAAQ,KAAK,GAAG;EACzB,IAAI,UAAU;EACd,MAAM,OAAO,MAAM,KAAK,SAAS;GAChC,MAAM,WAAW,uBAAuB,MAAM,QAAQ,CAAC;GACvD,IAAI,aAAa,MAAM,UAAU;GACjC,OAAO;EACR,CAAC;EACD,OAAQ,UAAU,OAAO;CAC1B;CACA,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,IAAI,UAAU,OAAO,aAAa,UAAU,MAAM,OAAO;CAEzD,IAAI;CACJ,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,KAAK,GAAG;EAChD,MAAM,WAAW,uBAAuB,MAAM,QAAQ,CAAC;EACvD,IAAI,aAAa,MAAM;GACtB,SAAS,EAAE,GAAI,MAAkC;GACjD,KAAK,OAAO;EACb;CACD;CACA,OAAQ,QAAQ;AACjB"}

package/dist/redact-paths.d.cts

@@ -13,5 +13,19 @@
  * - Wildcards: *.password, *.secret, *.token (catches nested fields)
  */
 export declare const DEFAULT_REDACT_PATHS: string[];
+/**
+ * Replace the credentials of every URL in `text` with `REDACTED`, so
+ * `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.
+ *
+ * Path redaction cannot catch these: a URL turns up under any field name —
+ * `url`, `origin`, `endpoint` — or inside a message, and blanking every such
+ * field would hide the half of it that is useful.
+ */
+export declare function redactUrlCredentials(text: string): string;
+/**
+ * A copy of `value` with {@link redactUrlCredentials} applied to every string
+ * in it. Objects and arrays without such a string are returned as they were.
+ */
+export declare function redactUrlCredentialsIn<T>(value: T, depth?: number): T;
 //#endregion
 //# sourceMappingURL=redact-paths.d.cts.map

package/dist/redact-paths.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"redact-paths.d.cts","names":[],"sources":["../src/redact-paths.ts"],"mappings":";;;;;;;;;;;;;;qBAaa"}
+{"version":3,"file":"redact-paths.d.cts","names":[],"sources":["../src/redact-paths.ts"],"mappings":";;;;;;;;;;;;;;qBAaa;;;;;;;;;wBA0EG,qBAAqB;;;;;wBAWrB,uBAAuB,GAAG,OAAO,GAAG,iBAAY"}

package/dist/redact-paths.d.mts

@@ -13,5 +13,19 @@
  * - Wildcards: *.password, *.secret, *.token (catches nested fields)
  */
 export declare const DEFAULT_REDACT_PATHS: string[];
+/**
+ * Replace the credentials of every URL in `text` with `REDACTED`, so
+ * `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.
+ *
+ * Path redaction cannot catch these: a URL turns up under any field name —
+ * `url`, `origin`, `endpoint` — or inside a message, and blanking every such
+ * field would hide the half of it that is useful.
+ */
+export declare function redactUrlCredentials(text: string): string;
+/**
+ * A copy of `value` with {@link redactUrlCredentials} applied to every string
+ * in it. Objects and arrays without such a string are returned as they were.
+ */
+export declare function redactUrlCredentialsIn<T>(value: T, depth?: number): T;
 //#endregion
 //# sourceMappingURL=redact-paths.d.mts.map

package/dist/redact-paths.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"redact-paths.d.mts","names":[],"sources":["../src/redact-paths.ts"],"mappings":";;;;;;;;;;;;;;qBAaa"}
+{"version":3,"file":"redact-paths.d.mts","names":[],"sources":["../src/redact-paths.ts"],"mappings":";;;;;;;;;;;;;;qBAaa;;;;;;;;;wBA0EG,qBAAqB;;;;;wBAWrB,uBAAuB,GAAG,OAAO,GAAG,iBAAY"}

package/dist/redact-paths.mjs

@@ -61,7 +61,54 @@ const DEFAULT_REDACT_PATHS = [
 	"databaseUrl",
 	"database_url"
 ];
+/**
+* `scheme://user:password@` — the userinfo of a URL that carries a secret.
+* A user with no password (`ssh://git@host`) names nobody's secret and is left
+* alone.
+*/
+const URL_CREDENTIALS = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/?#@:]*:[^\s/?#@]*@/gi;
+/**
+* Replace the credentials of every URL in `text` with `REDACTED`, so
+* `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.
+*
+* Path redaction cannot catch these: a URL turns up under any field name —
+* `url`, `origin`, `endpoint` — or inside a message, and blanking every such
+* field would hide the half of it that is useful.
+*/
+function redactUrlCredentials(text) {
+	return text.replace(URL_CREDENTIALS, "$1REDACTED@");
+}
+/** Deep enough for a log object; past it, values are logged as they are. */
+const MAX_DEPTH = 6;
+/**
+* A copy of `value` with {@link redactUrlCredentials} applied to every string
+* in it. Objects and arrays without such a string are returned as they were.
+*/
+function redactUrlCredentialsIn(value, depth = 0) {
+	if (typeof value === "string") return redactUrlCredentials(value);
+	if (depth >= MAX_DEPTH || value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((item) => {
+			const redacted = redactUrlCredentialsIn(item, depth + 1);
+			if (redacted !== item) changed = true;
+			return redacted;
+		});
+		return changed ? next : value;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return value;
+	let next;
+	for (const [key, item] of Object.entries(value)) {
+		const redacted = redactUrlCredentialsIn(item, depth + 1);
+		if (redacted !== item) {
+			next ??= { ...value };
+			next[key] = redacted;
+		}
+	}
+	return next ?? value;
+}
 //#endregion
-export { DEFAULT_REDACT_PATHS };
+export { DEFAULT_REDACT_PATHS, redactUrlCredentials, redactUrlCredentialsIn };
 
 //# sourceMappingURL=redact-paths.mjs.map

package/dist/redact-paths.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"redact-paths.mjs","names":[],"sources":["../src/redact-paths.ts"],"sourcesContent":["/**\n * Default sensitive field paths for redaction.\n *\n * These paths are automatically used when `redact: true` is set,\n * and merged with custom paths unless `resolution: 'override'` is specified.\n *\n * Includes:\n * - Authentication: password, token, apiKey, authorization, credentials\n * - Headers: authorization, cookie, x-api-key, x-auth-token\n * - Personal data: ssn, creditCard, cvv, pin\n * - Secrets: secret, connectionString, databaseUrl\n * - Wildcards: *.password, *.secret, *.token (catches nested fields)\n */\nexport const DEFAULT_REDACT_PATHS: string[] = [\n\t// Authentication & authorization\n\t'password',\n\t'pass',\n\t'passwd',\n\t'secret',\n\t'token',\n\t'accessToken',\n\t'refreshToken',\n\t'idToken',\n\t'apiKey',\n\t'api_key',\n\t'apikey',\n\t'auth',\n\t'authorization',\n\t'credential',\n\t'credentials',\n\n\t// Common nested patterns (headers, body, etc.)\n\t'*.password',\n\t'*.secret',\n\t'*.token',\n\t'*.apiKey',\n\t'*.api_key',\n\t'*.authorization',\n\t'*.accessToken',\n\t'*.refreshToken',\n\n\t// HTTP headers (case variations)\n\t'headers.authorization',\n\t'headers.Authorization',\n\t'headers[\"authorization\"]',\n\t'headers[\"Authorization\"]',\n\t'headers.cookie',\n\t'headers.Cookie',\n\t'headers[\"x-api-key\"]',\n\t'headers[\"X-Api-Key\"]',\n\t'headers[\"x-auth-token\"]',\n\t'headers[\"X-Auth-Token\"]',\n\n\t// Common sensitive data fields\n\t'ssn',\n\t'socialSecurityNumber',\n\t'social_security_number',\n\t'creditCard',\n\t'credit_card',\n\t'cardNumber',\n\t'card_number',\n\t'cvv',\n\t'cvc',\n\t'pin',\n\n\t// Database & connection strings\n\t'connectionString',\n\t'connection_string',\n\t'databaseUrl',\n\t'database_url',\n];\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,uBAAiC;CAE7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;AACD"}
+{"version":3,"file":"redact-paths.mjs","names":[],"sources":["../src/redact-paths.ts"],"sourcesContent":["/**\n * Default sensitive field paths for redaction.\n *\n * These paths are automatically used when `redact: true` is set,\n * and merged with custom paths unless `resolution: 'override'` is specified.\n *\n * Includes:\n * - Authentication: password, token, apiKey, authorization, credentials\n * - Headers: authorization, cookie, x-api-key, x-auth-token\n * - Personal data: ssn, creditCard, cvv, pin\n * - Secrets: secret, connectionString, databaseUrl\n * - Wildcards: *.password, *.secret, *.token (catches nested fields)\n */\nexport const DEFAULT_REDACT_PATHS: string[] = [\n\t// Authentication & authorization\n\t'password',\n\t'pass',\n\t'passwd',\n\t'secret',\n\t'token',\n\t'accessToken',\n\t'refreshToken',\n\t'idToken',\n\t'apiKey',\n\t'api_key',\n\t'apikey',\n\t'auth',\n\t'authorization',\n\t'credential',\n\t'credentials',\n\n\t// Common nested patterns (headers, body, etc.)\n\t'*.password',\n\t'*.secret',\n\t'*.token',\n\t'*.apiKey',\n\t'*.api_key',\n\t'*.authorization',\n\t'*.accessToken',\n\t'*.refreshToken',\n\n\t// HTTP headers (case variations)\n\t'headers.authorization',\n\t'headers.Authorization',\n\t'headers[\"authorization\"]',\n\t'headers[\"Authorization\"]',\n\t'headers.cookie',\n\t'headers.Cookie',\n\t'headers[\"x-api-key\"]',\n\t'headers[\"X-Api-Key\"]',\n\t'headers[\"x-auth-token\"]',\n\t'headers[\"X-Auth-Token\"]',\n\n\t// Common sensitive data fields\n\t'ssn',\n\t'socialSecurityNumber',\n\t'social_security_number',\n\t'creditCard',\n\t'credit_card',\n\t'cardNumber',\n\t'card_number',\n\t'cvv',\n\t'cvc',\n\t'pin',\n\n\t// Database & connection strings\n\t'connectionString',\n\t'connection_string',\n\t'databaseUrl',\n\t'database_url',\n];\n\n/**\n * `scheme://user:password@` — the userinfo of a URL that carries a secret.\n * A user with no password (`ssh://git@host`) names nobody's secret and is left\n * alone.\n */\nconst URL_CREDENTIALS = /\\b([a-z][a-z0-9+.-]*:\\/\\/)[^\\s/?#@:]*:[^\\s/?#@]*@/gi;\n\n/**\n * Replace the credentials of every URL in `text` with `REDACTED`, so\n * `s3://KEY:SECRET@uploads` is logged as `s3://REDACTED@uploads`.\n *\n * Path redaction cannot catch these: a URL turns up under any field name —\n * `url`, `origin`, `endpoint` — or inside a message, and blanking every such\n * field would hide the half of it that is useful.\n */\nexport function redactUrlCredentials(text: string): string {\n\treturn text.replace(URL_CREDENTIALS, '$1REDACTED@');\n}\n\n/** Deep enough for a log object; past it, values are logged as they are. */\nconst MAX_DEPTH = 6;\n\n/**\n * A copy of `value` with {@link redactUrlCredentials} applied to every string\n * in it. Objects and arrays without such a string are returned as they were.\n */\nexport function redactUrlCredentialsIn<T>(value: T, depth = 0): T {\n\tif (typeof value === 'string') {\n\t\treturn redactUrlCredentials(value) as T;\n\t}\n\tif (depth >= MAX_DEPTH || value === null || typeof value !== 'object') {\n\t\treturn value;\n\t}\n\tif (Array.isArray(value)) {\n\t\tlet changed = false;\n\t\tconst next = value.map((item) => {\n\t\t\tconst redacted = redactUrlCredentialsIn(item, depth + 1);\n\t\t\tif (redacted !== item) changed = true;\n\t\t\treturn redacted;\n\t\t});\n\t\treturn (changed ? next : value) as T;\n\t}\n\tconst proto = Object.getPrototypeOf(value);\n\tif (proto !== Object.prototype && proto !== null) return value;\n\n\tlet next: Record<string, unknown> | undefined;\n\tfor (const [key, item] of Object.entries(value)) {\n\t\tconst redacted = redactUrlCredentialsIn(item, depth + 1);\n\t\tif (redacted !== item) {\n\t\t\tnext ??= { ...(value as Record<string, unknown>) };\n\t\t\tnext[key] = redacted;\n\t\t}\n\t}\n\treturn (next ?? value) as T;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,uBAAiC;CAE7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;AACD;;;;;;AAOA,MAAM,kBAAkB;;;;;;;;;AAUxB,SAAgB,qBAAqB,MAAsB;CAC1D,OAAO,KAAK,QAAQ,iBAAiB,aAAa;AACnD;;AAGA,MAAM,YAAY;;;;;AAMlB,SAAgB,uBAA0B,OAAU,QAAQ,GAAM;CACjE,IAAI,OAAO,UAAU,UACpB,OAAO,qBAAqB,KAAK;CAElC,IAAI,SAAS,aAAa,UAAU,QAAQ,OAAO,UAAU,UAC5D,OAAO;CAER,IAAI,MAAM,QAAQ,KAAK,GAAG;EACzB,IAAI,UAAU;EACd,MAAM,OAAO,MAAM,KAAK,SAAS;GAChC,MAAM,WAAW,uBAAuB,MAAM,QAAQ,CAAC;GACvD,IAAI,aAAa,MAAM,UAAU;GACjC,OAAO;EACR,CAAC;EACD,OAAQ,UAAU,OAAO;CAC1B;CACA,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,IAAI,UAAU,OAAO,aAAa,UAAU,MAAM,OAAO;CAEzD,IAAI;CACJ,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,KAAK,GAAG;EAChD,MAAM,WAAW,uBAAuB,MAAM,QAAQ,CAAC;EACvD,IAAI,aAAa,MAAM;GACtB,SAAS,EAAE,GAAI,MAAkC;GACjD,KAAK,OAAO;EACb;CACD;CACA,OAAQ,QAAQ;AACjB"}

package/dist/types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Logging function type that supports both structured and simple logging.\n * Can be called with an object for structured logging or just a message string.\n *\n * @example\n * ```typescript\n * // Structured logging with context object\n * logger.info({ userId: 123, action: 'login' }, 'User logged in');\n *\n * // Simple string logging\n * logger.info('Application started');\n * ```\n */\nexport type LogFn = {\n\t/** Structured logging with context object, optional message, and additional arguments */\n\t<T extends object>(obj: T, msg?: string, ...args: any[]): void;\n\t/** Simple string logging */\n\t(msg: string): void;\n};\n\n/**\n * Standard logger interface with multiple log levels and child logger support.\n * Follows common logging patterns with structured logging capabilities.\n *\n * @interface Logger\n */\nexport interface Logger {\n\t/** Debug level logging - verbose information for debugging */\n\tdebug: LogFn;\n\t/** Info level logging - general informational messages */\n\tinfo: LogFn;\n\t/** Warning level logging - potentially harmful situations */\n\twarn: LogFn;\n\t/** Error level logging - error events that might still allow the application to continue */\n\terror: LogFn;\n\t/** Fatal level logging - severe errors that will likely cause the application to abort */\n\tfatal: LogFn;\n\t/** Trace level logging - most detailed information */\n\ttrace: LogFn;\n\t/**\n\t * Creates a child logger with additional context.\n\t * Child loggers inherit parent context and add their own.\n\t *\n\t * @param obj - Additional context to include in all child logger calls\n\t * @returns A new Logger instance with merged context\n\t */\n\tchild: (obj: object) => Logger;\n}\n\n/**\n * Console-based logger implementation that outputs to standard console methods.\n * Supports structured logging with automatic timestamp injection and context inheritance.\n *\n * @implements {Logger}\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });\n * logger.info({ userId: 123 }, 'User action performed');\n * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed\n *\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ action: 'validate' }, 'Validating token');\n * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token\n * ```\n */\nexport enum LogLevel {\n\tTrace = 'trace',\n\tDebug = 'debug',\n\tInfo = 'info',\n\tWarn = 'warn',\n\tError = 'error',\n\tFatal = 'fatal',\n\tSilent = 'silent',\n}\n\n/**\n * Redaction configuration for masking sensitive data in logs.\n * Uses pino's fast-redact library under the hood.\n *\n * By default, custom paths are merged with the default sensitive paths.\n * Use `resolution: 'override'` to use only your custom paths.\n *\n * @example\n * ```typescript\n * // Simple path array (merges with defaults)\n * redact: ['user.ssn', 'custom.field']\n *\n * // Override defaults completely\n * redact: {\n *   paths: ['only.these.paths'],\n *   resolution: 'override',\n * }\n *\n * // With custom censor\n * redact: {\n *   paths: ['extra.secret'],\n *   censor: '***',\n * }\n *\n * // Remove fields entirely\n * redact: {\n *   paths: ['temporary.data'],\n *   remove: true,\n * }\n * ```\n */\nexport type RedactOptions =\n\t| string[]\n\t| {\n\t\t\t/** Paths to redact using dot notation or bracket notation for special chars */\n\t\t\tpaths: string[];\n\t\t\t/** Custom replacement text (default: '[REDACTED]') */\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\t/** Remove the field entirely instead of replacing (default: false) */\n\t\t\tremove?: boolean;\n\t\t\t/**\n\t\t\t * How to combine custom paths with default sensitive paths.\n\t\t\t * - 'merge': Custom paths are added to default paths (default)\n\t\t\t * - 'override': Only custom paths are used, defaults are ignored\n\t\t\t */\n\t\t\tresolution?: 'merge' | 'override';\n\t  };\n\nexport type CreateLoggerOptions = {\n\t/** Enable pretty printing with colors (disabled in production) */\n\tpretty?: boolean;\n\t/** Minimum log level to output */\n\tlevel?: LogLevel;\n\t/**\n\t * Redaction configuration for masking sensitive data.\n\t *\n\t * - `true`: Uses default sensitive paths (password, token, secret, etc.)\n\t * - `false` or `undefined`: No redaction applied\n\t * - `string[]`: Custom paths merged with defaults\n\t * - `object`: Advanced config with paths, censor, remove, and resolution options\n\t *\n\t * By default, custom paths are **merged** with the default sensitive paths.\n\t * Use `resolution: 'override'` to disable defaults and use only your paths.\n\t *\n\t * @example\n\t * ```typescript\n\t * // Use defaults only\n\t * createLogger({ redact: true });\n\t *\n\t * // Add custom paths (merged with defaults)\n\t * createLogger({ redact: ['user.ssn', 'custom.field'] });\n\t *\n\t * // Override defaults completely\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['only.these.paths'],\n\t *     resolution: 'override',\n\t *   }\n\t * });\n\t *\n\t * // Merge with custom censor\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['extra.secret'],\n\t *     censor: '***',\n\t *   }\n\t * });\n\t * ```\n\t */\n\tredact?: boolean | RedactOptions;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkEA,IAAY,WAAL,yBAAA,UAAA;CACN,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,UAAA;CACA,SAAA,UAAA;CACA,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,YAAA;;AACD,EAAA,CAAA,CAAA"}
+{"version":3,"file":"types.cjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Logging function type that supports both structured and simple logging.\n * Can be called with an object for structured logging or just a message string.\n *\n * @example\n * ```typescript\n * // Structured logging with context object\n * logger.info({ userId: 123, action: 'login' }, 'User logged in');\n *\n * // Simple string logging\n * logger.info('Application started');\n * ```\n */\nexport type LogFn = {\n\t/** Structured logging with context object, optional message, and additional arguments */\n\t<T extends object>(obj: T, msg?: string, ...args: any[]): void;\n\t/** Simple string logging */\n\t(msg: string): void;\n};\n\n/**\n * Standard logger interface with multiple log levels and child logger support.\n * Follows common logging patterns with structured logging capabilities.\n *\n * @interface Logger\n */\nexport interface Logger {\n\t/** Debug level logging - verbose information for debugging */\n\tdebug: LogFn;\n\t/** Info level logging - general informational messages */\n\tinfo: LogFn;\n\t/** Warning level logging - potentially harmful situations */\n\twarn: LogFn;\n\t/** Error level logging - error events that might still allow the application to continue */\n\terror: LogFn;\n\t/** Fatal level logging - severe errors that will likely cause the application to abort */\n\tfatal: LogFn;\n\t/** Trace level logging - most detailed information */\n\ttrace: LogFn;\n\t/**\n\t * Creates a child logger with additional context.\n\t * Child loggers inherit parent context and add their own.\n\t *\n\t * @param obj - Additional context to include in all child logger calls\n\t * @returns A new Logger instance with merged context\n\t */\n\tchild: (obj: object) => Logger;\n}\n\n/**\n * Console-based logger implementation that outputs to standard console methods.\n * Supports structured logging with automatic timestamp injection and context inheritance.\n *\n * @implements {Logger}\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });\n * logger.info({ userId: 123 }, 'User action performed');\n * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed\n *\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ action: 'validate' }, 'Validating token');\n * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token\n * ```\n */\nexport enum LogLevel {\n\tTrace = 'trace',\n\tDebug = 'debug',\n\tInfo = 'info',\n\tWarn = 'warn',\n\tError = 'error',\n\tFatal = 'fatal',\n\tSilent = 'silent',\n}\n\n/**\n * Redaction configuration for masking sensitive data in logs.\n * Uses pino's fast-redact library under the hood.\n *\n * By default, custom paths are merged with the default sensitive paths.\n * Use `resolution: 'override'` to use only your custom paths.\n *\n * @example\n * ```typescript\n * // Simple path array (merges with defaults)\n * redact: ['user.ssn', 'custom.field']\n *\n * // Override defaults completely\n * redact: {\n *   paths: ['only.these.paths'],\n *   resolution: 'override',\n * }\n *\n * // With custom censor\n * redact: {\n *   paths: ['extra.secret'],\n *   censor: '***',\n * }\n *\n * // Remove fields entirely\n * redact: {\n *   paths: ['temporary.data'],\n *   remove: true,\n * }\n * ```\n */\nexport type RedactOptions =\n\t| string[]\n\t| {\n\t\t\t/** Paths to redact using dot notation or bracket notation for special chars */\n\t\t\tpaths: string[];\n\t\t\t/** Custom replacement text (default: '[REDACTED]') */\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\t/** Remove the field entirely instead of replacing (default: false) */\n\t\t\tremove?: boolean;\n\t\t\t/**\n\t\t\t * How to combine custom paths with default sensitive paths.\n\t\t\t * - 'merge': Custom paths are added to default paths (default)\n\t\t\t * - 'override': Only custom paths are used, defaults are ignored\n\t\t\t */\n\t\t\tresolution?: 'merge' | 'override';\n\t  };\n\nexport type CreateLoggerOptions = {\n\t/** Enable pretty printing with colors (disabled in production) */\n\tpretty?: boolean;\n\t/** Minimum log level to output */\n\tlevel?: LogLevel;\n\t/**\n\t * Redaction configuration for masking sensitive data.\n\t *\n\t * - `true` or `undefined` (the default): Uses default sensitive paths\n\t *   (password, token, secret, etc.)\n\t * - `false`: No redaction applied — the explicit opt-out\n\t * - `string[]`: Custom paths merged with defaults\n\t * - `object`: Advanced config with paths, censor, remove, and resolution options\n\t *\n\t * By default, custom paths are **merged** with the default sensitive paths.\n\t * Use `resolution: 'override'` to disable defaults and use only your paths.\n\t *\n\t * @example\n\t * ```typescript\n\t * // Use defaults only (the same as leaving `redact` out)\n\t * createLogger({ redact: true });\n\t *\n\t * // Opt out\n\t * createLogger({ redact: false });\n\t *\n\t * // Add custom paths (merged with defaults)\n\t * createLogger({ redact: ['user.ssn', 'custom.field'] });\n\t *\n\t * // Override defaults completely\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['only.these.paths'],\n\t *     resolution: 'override',\n\t *   }\n\t * });\n\t *\n\t * // Merge with custom censor\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['extra.secret'],\n\t *     censor: '***',\n\t *   }\n\t * });\n\t * ```\n\t */\n\tredact?: boolean | RedactOptions;\n\t/**\n\t * Where log lines are written (pino logger only). Defaults to stdout.\n\t * Ignored when `pretty` is on, since the pretty transport owns its output.\n\t */\n\tdestination?: { write(line: string): unknown };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkEA,IAAY,WAAL,yBAAA,UAAA;CACN,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,UAAA;CACA,SAAA,UAAA;CACA,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,YAAA;;AACD,EAAA,CAAA,CAAA"}

package/dist/types.d.cts

@@ -125,8 +125,9 @@ export type CreateLoggerOptions = {
   /**
    * Redaction configuration for masking sensitive data.
    *
-   * - `true`: Uses default sensitive paths (password, token, secret, etc.)
-   * - `false` or `undefined`: No redaction applied
+   * - `true` or `undefined` (the default): Uses default sensitive paths
+   *   (password, token, secret, etc.)
+   * - `false`: No redaction applied — the explicit opt-out
    * - `string[]`: Custom paths merged with defaults
    * - `object`: Advanced config with paths, censor, remove, and resolution options
    *
@@ -135,9 +136,12 @@ export type CreateLoggerOptions = {
    *
    * @example
    * ```typescript
-   * // Use defaults only
+   * // Use defaults only (the same as leaving `redact` out)
    * createLogger({ redact: true });
    *
+   * // Opt out
+   * createLogger({ redact: false });
+   *
    * // Add custom paths (merged with defaults)
    * createLogger({ redact: ['user.ssn', 'custom.field'] });
    *
@@ -159,6 +163,13 @@ export type CreateLoggerOptions = {
    * ```
    */
   redact?: boolean | RedactOptions;
+  /**
+   * Where log lines are written (pino logger only). Defaults to stdout.
+   * Ignored when `pretty` is on, since the pretty transport owns its output.
+   */
+  destination?: {
+    write(line: string): unknown;
+  };
 };
 //#endregion
 //# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;YAaY;;GAEV,kBAAkB,KAAK,GAAG,iBAAiB;;GAE3C;;;;;;;;iBASe;;EAEhB,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;EAEP,OAAO;;;;;;;;EAQP,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;oBAoBb;EACX;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCW;;EAIT;;EAEA,oBAAoB,gBAAgB;;EAEpC;;;;;;EAMA;;YAGS;;EAEX;;EAEA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCR,mBAAmB"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;YAaY;;GAEV,kBAAkB,KAAK,GAAG,iBAAiB;;GAE3C;;;;;;;;iBASe;;EAEhB,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;EAEP,OAAO;;;;;;;;EAQP,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;oBAoBb;EACX;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCW;;EAIT;;EAEA,oBAAoB,gBAAgB;;EAEpC;;;;;;EAMA;;YAGS;;EAEX;;EAEA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCR,mBAAmB;;;;;EAKnB;IAAgB,MAAM"}

package/dist/types.d.mts

@@ -125,8 +125,9 @@ export type CreateLoggerOptions = {
   /**
    * Redaction configuration for masking sensitive data.
    *
-   * - `true`: Uses default sensitive paths (password, token, secret, etc.)
-   * - `false` or `undefined`: No redaction applied
+   * - `true` or `undefined` (the default): Uses default sensitive paths
+   *   (password, token, secret, etc.)
+   * - `false`: No redaction applied — the explicit opt-out
    * - `string[]`: Custom paths merged with defaults
    * - `object`: Advanced config with paths, censor, remove, and resolution options
    *
@@ -135,9 +136,12 @@ export type CreateLoggerOptions = {
    *
    * @example
    * ```typescript
-   * // Use defaults only
+   * // Use defaults only (the same as leaving `redact` out)
    * createLogger({ redact: true });
    *
+   * // Opt out
+   * createLogger({ redact: false });
+   *
    * // Add custom paths (merged with defaults)
    * createLogger({ redact: ['user.ssn', 'custom.field'] });
    *
@@ -159,6 +163,13 @@ export type CreateLoggerOptions = {
    * ```
    */
   redact?: boolean | RedactOptions;
+  /**
+   * Where log lines are written (pino logger only). Defaults to stdout.
+   * Ignored when `pretty` is on, since the pretty transport owns its output.
+   */
+  destination?: {
+    write(line: string): unknown;
+  };
 };
 //#endregion
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;YAaY;;GAEV,kBAAkB,KAAK,GAAG,iBAAiB;;GAE3C;;;;;;;;iBASe;;EAEhB,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;EAEP,OAAO;;;;;;;;EAQP,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;oBAoBb;EACX;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCW;;EAIT;;EAEA,oBAAoB,gBAAgB;;EAEpC;;;;;;EAMA;;YAGS;;EAEX;;EAEA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCR,mBAAmB"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;;;;;;;;YAaY;;GAEV,kBAAkB,KAAK,GAAG,iBAAiB;;GAE3C;;;;;;;;iBASe;;EAEhB,OAAO;;EAEP,MAAM;;EAEN,MAAM;;EAEN,OAAO;;EAEP,OAAO;;EAEP,OAAO;;;;;;;;EAQP,QAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;oBAoBb;EACX;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAkCW;;EAIT;;EAEA,oBAAoB,gBAAgB;;EAEpC;;;;;;EAMA;;YAGS;;EAEX;;EAEA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCR,mBAAmB;;;;;EAKnB;IAAgB,MAAM"}

package/dist/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Logging function type that supports both structured and simple logging.\n * Can be called with an object for structured logging or just a message string.\n *\n * @example\n * ```typescript\n * // Structured logging with context object\n * logger.info({ userId: 123, action: 'login' }, 'User logged in');\n *\n * // Simple string logging\n * logger.info('Application started');\n * ```\n */\nexport type LogFn = {\n\t/** Structured logging with context object, optional message, and additional arguments */\n\t<T extends object>(obj: T, msg?: string, ...args: any[]): void;\n\t/** Simple string logging */\n\t(msg: string): void;\n};\n\n/**\n * Standard logger interface with multiple log levels and child logger support.\n * Follows common logging patterns with structured logging capabilities.\n *\n * @interface Logger\n */\nexport interface Logger {\n\t/** Debug level logging - verbose information for debugging */\n\tdebug: LogFn;\n\t/** Info level logging - general informational messages */\n\tinfo: LogFn;\n\t/** Warning level logging - potentially harmful situations */\n\twarn: LogFn;\n\t/** Error level logging - error events that might still allow the application to continue */\n\terror: LogFn;\n\t/** Fatal level logging - severe errors that will likely cause the application to abort */\n\tfatal: LogFn;\n\t/** Trace level logging - most detailed information */\n\ttrace: LogFn;\n\t/**\n\t * Creates a child logger with additional context.\n\t * Child loggers inherit parent context and add their own.\n\t *\n\t * @param obj - Additional context to include in all child logger calls\n\t * @returns A new Logger instance with merged context\n\t */\n\tchild: (obj: object) => Logger;\n}\n\n/**\n * Console-based logger implementation that outputs to standard console methods.\n * Supports structured logging with automatic timestamp injection and context inheritance.\n *\n * @implements {Logger}\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });\n * logger.info({ userId: 123 }, 'User action performed');\n * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed\n *\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ action: 'validate' }, 'Validating token');\n * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token\n * ```\n */\nexport enum LogLevel {\n\tTrace = 'trace',\n\tDebug = 'debug',\n\tInfo = 'info',\n\tWarn = 'warn',\n\tError = 'error',\n\tFatal = 'fatal',\n\tSilent = 'silent',\n}\n\n/**\n * Redaction configuration for masking sensitive data in logs.\n * Uses pino's fast-redact library under the hood.\n *\n * By default, custom paths are merged with the default sensitive paths.\n * Use `resolution: 'override'` to use only your custom paths.\n *\n * @example\n * ```typescript\n * // Simple path array (merges with defaults)\n * redact: ['user.ssn', 'custom.field']\n *\n * // Override defaults completely\n * redact: {\n *   paths: ['only.these.paths'],\n *   resolution: 'override',\n * }\n *\n * // With custom censor\n * redact: {\n *   paths: ['extra.secret'],\n *   censor: '***',\n * }\n *\n * // Remove fields entirely\n * redact: {\n *   paths: ['temporary.data'],\n *   remove: true,\n * }\n * ```\n */\nexport type RedactOptions =\n\t| string[]\n\t| {\n\t\t\t/** Paths to redact using dot notation or bracket notation for special chars */\n\t\t\tpaths: string[];\n\t\t\t/** Custom replacement text (default: '[REDACTED]') */\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\t/** Remove the field entirely instead of replacing (default: false) */\n\t\t\tremove?: boolean;\n\t\t\t/**\n\t\t\t * How to combine custom paths with default sensitive paths.\n\t\t\t * - 'merge': Custom paths are added to default paths (default)\n\t\t\t * - 'override': Only custom paths are used, defaults are ignored\n\t\t\t */\n\t\t\tresolution?: 'merge' | 'override';\n\t  };\n\nexport type CreateLoggerOptions = {\n\t/** Enable pretty printing with colors (disabled in production) */\n\tpretty?: boolean;\n\t/** Minimum log level to output */\n\tlevel?: LogLevel;\n\t/**\n\t * Redaction configuration for masking sensitive data.\n\t *\n\t * - `true`: Uses default sensitive paths (password, token, secret, etc.)\n\t * - `false` or `undefined`: No redaction applied\n\t * - `string[]`: Custom paths merged with defaults\n\t * - `object`: Advanced config with paths, censor, remove, and resolution options\n\t *\n\t * By default, custom paths are **merged** with the default sensitive paths.\n\t * Use `resolution: 'override'` to disable defaults and use only your paths.\n\t *\n\t * @example\n\t * ```typescript\n\t * // Use defaults only\n\t * createLogger({ redact: true });\n\t *\n\t * // Add custom paths (merged with defaults)\n\t * createLogger({ redact: ['user.ssn', 'custom.field'] });\n\t *\n\t * // Override defaults completely\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['only.these.paths'],\n\t *     resolution: 'override',\n\t *   }\n\t * });\n\t *\n\t * // Merge with custom censor\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['extra.secret'],\n\t *     censor: '***',\n\t *   }\n\t * });\n\t * ```\n\t */\n\tredact?: boolean | RedactOptions;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkEA,IAAY,WAAL,yBAAA,UAAA;CACN,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,UAAA;CACA,SAAA,UAAA;CACA,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,YAAA;;AACD,EAAA,CAAA,CAAA"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Logging function type that supports both structured and simple logging.\n * Can be called with an object for structured logging or just a message string.\n *\n * @example\n * ```typescript\n * // Structured logging with context object\n * logger.info({ userId: 123, action: 'login' }, 'User logged in');\n *\n * // Simple string logging\n * logger.info('Application started');\n * ```\n */\nexport type LogFn = {\n\t/** Structured logging with context object, optional message, and additional arguments */\n\t<T extends object>(obj: T, msg?: string, ...args: any[]): void;\n\t/** Simple string logging */\n\t(msg: string): void;\n};\n\n/**\n * Standard logger interface with multiple log levels and child logger support.\n * Follows common logging patterns with structured logging capabilities.\n *\n * @interface Logger\n */\nexport interface Logger {\n\t/** Debug level logging - verbose information for debugging */\n\tdebug: LogFn;\n\t/** Info level logging - general informational messages */\n\tinfo: LogFn;\n\t/** Warning level logging - potentially harmful situations */\n\twarn: LogFn;\n\t/** Error level logging - error events that might still allow the application to continue */\n\terror: LogFn;\n\t/** Fatal level logging - severe errors that will likely cause the application to abort */\n\tfatal: LogFn;\n\t/** Trace level logging - most detailed information */\n\ttrace: LogFn;\n\t/**\n\t * Creates a child logger with additional context.\n\t * Child loggers inherit parent context and add their own.\n\t *\n\t * @param obj - Additional context to include in all child logger calls\n\t * @returns A new Logger instance with merged context\n\t */\n\tchild: (obj: object) => Logger;\n}\n\n/**\n * Console-based logger implementation that outputs to standard console methods.\n * Supports structured logging with automatic timestamp injection and context inheritance.\n *\n * @implements {Logger}\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger({ app: 'myApp', version: '1.0.0' });\n * logger.info({ userId: 123 }, 'User action performed');\n * // Output: { app: 'myApp', version: '1.0.0', userId: 123, ts: 1234567890 } User action performed\n *\n * const childLogger = logger.child({ module: 'auth' });\n * childLogger.debug({ action: 'validate' }, 'Validating token');\n * // Output: { app: 'myApp', version: '1.0.0', module: 'auth', action: 'validate', ts: 1234567891 } Validating token\n * ```\n */\nexport enum LogLevel {\n\tTrace = 'trace',\n\tDebug = 'debug',\n\tInfo = 'info',\n\tWarn = 'warn',\n\tError = 'error',\n\tFatal = 'fatal',\n\tSilent = 'silent',\n}\n\n/**\n * Redaction configuration for masking sensitive data in logs.\n * Uses pino's fast-redact library under the hood.\n *\n * By default, custom paths are merged with the default sensitive paths.\n * Use `resolution: 'override'` to use only your custom paths.\n *\n * @example\n * ```typescript\n * // Simple path array (merges with defaults)\n * redact: ['user.ssn', 'custom.field']\n *\n * // Override defaults completely\n * redact: {\n *   paths: ['only.these.paths'],\n *   resolution: 'override',\n * }\n *\n * // With custom censor\n * redact: {\n *   paths: ['extra.secret'],\n *   censor: '***',\n * }\n *\n * // Remove fields entirely\n * redact: {\n *   paths: ['temporary.data'],\n *   remove: true,\n * }\n * ```\n */\nexport type RedactOptions =\n\t| string[]\n\t| {\n\t\t\t/** Paths to redact using dot notation or bracket notation for special chars */\n\t\t\tpaths: string[];\n\t\t\t/** Custom replacement text (default: '[REDACTED]') */\n\t\t\tcensor?: string | ((value: unknown, path: string[]) => unknown);\n\t\t\t/** Remove the field entirely instead of replacing (default: false) */\n\t\t\tremove?: boolean;\n\t\t\t/**\n\t\t\t * How to combine custom paths with default sensitive paths.\n\t\t\t * - 'merge': Custom paths are added to default paths (default)\n\t\t\t * - 'override': Only custom paths are used, defaults are ignored\n\t\t\t */\n\t\t\tresolution?: 'merge' | 'override';\n\t  };\n\nexport type CreateLoggerOptions = {\n\t/** Enable pretty printing with colors (disabled in production) */\n\tpretty?: boolean;\n\t/** Minimum log level to output */\n\tlevel?: LogLevel;\n\t/**\n\t * Redaction configuration for masking sensitive data.\n\t *\n\t * - `true` or `undefined` (the default): Uses default sensitive paths\n\t *   (password, token, secret, etc.)\n\t * - `false`: No redaction applied — the explicit opt-out\n\t * - `string[]`: Custom paths merged with defaults\n\t * - `object`: Advanced config with paths, censor, remove, and resolution options\n\t *\n\t * By default, custom paths are **merged** with the default sensitive paths.\n\t * Use `resolution: 'override'` to disable defaults and use only your paths.\n\t *\n\t * @example\n\t * ```typescript\n\t * // Use defaults only (the same as leaving `redact` out)\n\t * createLogger({ redact: true });\n\t *\n\t * // Opt out\n\t * createLogger({ redact: false });\n\t *\n\t * // Add custom paths (merged with defaults)\n\t * createLogger({ redact: ['user.ssn', 'custom.field'] });\n\t *\n\t * // Override defaults completely\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['only.these.paths'],\n\t *     resolution: 'override',\n\t *   }\n\t * });\n\t *\n\t * // Merge with custom censor\n\t * createLogger({\n\t *   redact: {\n\t *     paths: ['extra.secret'],\n\t *     censor: '***',\n\t *   }\n\t * });\n\t * ```\n\t */\n\tredact?: boolean | RedactOptions;\n\t/**\n\t * Where log lines are written (pino logger only). Defaults to stdout.\n\t * Ignored when `pretty` is on, since the pretty transport owns its output.\n\t */\n\tdestination?: { write(line: string): unknown };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkEA,IAAY,WAAL,yBAAA,UAAA;CACN,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,UAAA;CACA,SAAA,UAAA;CACA,SAAA,WAAA;CACA,SAAA,WAAA;CACA,SAAA,YAAA;;AACD,EAAA,CAAA,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/logger",
-  "version": "10.0.0-alpha.14",
+  "version": "10.0.0-alpha.141",
   "description": "A simple and flexible logging library for Node.js and the browser",
   "private": false,
   "type": "module",
@@ -35,6 +35,16 @@
         "default": "./dist/console.cjs"
       }
     },
+    "./otel": {
+      "import": {
+        "types": "./dist/otel.d.mts",
+        "default": "./dist/otel.mjs"
+      },
+      "require": {
+        "types": "./dist/otel.d.cts",
+        "default": "./dist/otel.cjs"
+      }
+    },
     "./redact": {
       "import": {
         "types": "./dist/redact-paths.d.mts",
@@ -57,8 +67,14 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "dependencies": {},
-  "devDependencies": {},
+  "dependencies": {
+    "@opentelemetry/api-logs": "~0.222.0"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "~1.9.1",
+    "@opentelemetry/sdk-logs": "~0.222.0",
+    "@opentelemetry/sdk-trace-node": "~2.11.0"
+  },
   "peerDependencies": {
     "pino-pretty": ">=13.1.3",
     "pino": ">=10.3.1"
@@ -70,5 +86,8 @@
     "pino-pretty": {
       "optional": true
     }
+  },
+  "scripts": {
+    "build": "tsdown --config ../../tsdown.config.ts --filter ."
   }
 }