logixia 2.0.10 → 2.1.0

package/dist/nest.mjs

@@ -1,9 +1,10 @@
-import { S as DEFAULT_CONFIG, T as LogLevel, _ as serializeError, a as isLogixiaException, o as LogixiaLogger, t as ErrorResponseBuilder } from "./builder-Bj3mDeBw.mjs";
-import { a as buildNameSet, c as sensitiveQueryValues, l as assignOwn, n as DEFAULT_REDACT_QUERY_PARAMS, o as redactUrlQuery, s as sanitizeText } from "./sensitive-names-o__1PUUR.mjs";
-import { d as getTraceContextKey, l as extractTraceId, o as TraceContext, p as sanitizeIncomingId, r as DEFAULT_TRACE_HEADERS } from "./request-trace-BgNykH9M.mjs";
-import { n as protectSecrets } from "./secret-config-ByGq7kJd.mjs";
+import { S as DEFAULT_CONFIG, T as LogLevel, _ as serializeError, a as isLogixiaException, o as LogixiaLogger, t as ErrorResponseBuilder } from "./builder-CA_dokb4.mjs";
+import { t as assignOwn } from "./own-property-CjFw9qwZ.mjs";
+import { d as getTraceContextKey, l as extractTraceId, o as TraceContext, p as sanitizeIncomingId, r as DEFAULT_TRACE_HEADERS } from "./request-trace-Dekcnenb.mjs";
+import { a as buildNameSet, c as sanitizeText, l as sensitiveQueryValues, n as DEFAULT_REDACT_QUERY_PARAMS, o as redactUrlQuery } from "./sensitive-names-BiBM6R1X.mjs";
+import { n as protectSecrets } from "./secret-config-GKmb15Me.mjs";
 import { r as internalWarn, t as internalError } from "./internal-log-Cy5nF1ZL.mjs";
-import { t as safeToString } from "./coerce.utils-B_rEudCn.mjs";
+import { n as safeToString } from "./csv.utils-ZdxSod5g.mjs";
 import { Catch, Inject, Injectable, Module, Optional, RequestMethod, Scope } from "@nestjs/common";
 import { EMPTY, Observable } from "rxjs";
 // \0@oxc-project+runtime@0.155.0/helpers/esm/decorateMetadata.js
@@ -19,9 +20,37 @@ function __decorate(decorators, target, key, desc) {
 }
 // src/core/logitron-nestjs.service.ts
 var _LogixiaLoggerService;
+const looksLikeStack = (value) => value.includes("\n    at ");
+const NEST_LEVEL_TO_LOGIXIA = {
+	fatal: LogLevel.ERROR,
+	error: LogLevel.ERROR,
+	warn: LogLevel.WARN,
+	log: LogLevel.INFO,
+	debug: LogLevel.DEBUG,
+	verbose: LogLevel.TRACE
+};
+const LEVEL_VERBOSITY = [
+	LogLevel.ERROR,
+	LogLevel.WARN,
+	LogLevel.INFO,
+	LogLevel.DEBUG,
+	LogLevel.TRACE
+];
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function describeObject(value) {
+	var _value$constructor;
+	return Array.isArray(value) ? safeToString(value) : `[${((_value$constructor = value.constructor) === null || _value$constructor === void 0 ? void 0 : _value$constructor.name) ?? "Object"}]`;
+}
 let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
+	logger;
+	context;
+	_mergedConfig;
 	constructor(config) {
-		const defaultConfig = {
+		const mergedConfig = {
 			appName: "NestJS-App",
 			environment: "development",
 			traceId: true,
@@ -56,37 +85,40 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 				message: "[message]",
 				payload: "[payload]",
 				timeTaken: "[time_taken_MS]"
-			}
-		};
-		protectSecrets(this, ["_mergedConfig"]);
-		this._mergedConfig = {
-			...defaultConfig,
+			},
 			...config
 		};
-		this.logger = new LogixiaLogger(this._mergedConfig);
+		this._attach(mergedConfig, new LogixiaLogger(mergedConfig));
+	}
+	_attach(mergedConfig, logger) {
+		protectSecrets(this, ["_mergedConfig"]);
+		this._mergedConfig = mergedConfig;
+		this.logger = logger;
 		this._createCustomLevelMethods();
 	}
 	_createCustomLevelMethods() {
 		var _this$_mergedConfig$l;
 		const levels = (_this$_mergedConfig$l = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l === void 0 ? void 0 : _this$_mergedConfig$l.levels;
 		if (!levels) return;
-		for (const levelName of Object.keys(levels)) {
-			const lower = levelName.toLowerCase();
-			if (typeof this[lower] !== "undefined") continue;
-			this[lower] = async (message, data) => {
-				return this.logger.logLevel(lower, message, data);
-			};
-		}
+		const self = this;
+		const define = (method, levelName) => {
+			if (typeof self[method] !== "undefined") return;
+			self[method] = async (message, data) => this.logger.logLevel(levelName, message, data);
+		};
+		const names = Object.keys(levels);
+		for (const levelName of names) define(levelName, levelName);
+		for (const levelName of names) define(levelName.toLowerCase(), levelName);
 	}
 	/**
-	* NestJS `LoggerService.log` — void, string context.
-	* Maps internally to `info`.
+	* NestJS `LoggerService.log` — void. Maps internally to `info`.
+	* A trailing string is the context for this call only; object params are merged into the payload.
 	*
 	* @example `logger.log('User signed up', 'AuthService')`
+	* @example `logger.log('User signed up', { userId: 'u_abc' }, 'AuthService')`
 	*/
-	log(message, context) {
-		this.setContextIfProvided(context);
-		this.logger.info(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.log failed", err));
+	log(message, ...optionalParams) {
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("log", this.withContext(context, () => this.logger.info(this.formatMessage(message), data)));
 	}
 	/**
 	* Native async `info` — structured data, returns `Promise<void>`.
@@ -96,27 +128,49 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	async info(message, data) {
 		return this.logger.info(message, data);
 	}
-	error(message, dataOrTrace, context) {
-		if (typeof dataOrTrace === "object" && dataOrTrace !== null) return message instanceof Error ? this.logger.error(message, dataOrTrace) : this.logger.error(this.formatMessage(message), dataOrTrace);
-		this.setContextIfProvided(context);
-		const errorData = {};
-		if (typeof dataOrTrace === "string" && dataOrTrace) errorData.stack = dataOrTrace;
-		(message instanceof Error ? this.logger.error(message, errorData) : this.logger.error(this.formatMessage(message), errorData)).catch((err) => internalError("LogixiaLoggerService.error failed", err));
+	error(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) {
+			const data = only;
+			return message instanceof Error ? this.logger.error(message, data) : this.logger.error(this.formatMessage(message), data);
+		}
+		const { context, data } = this.parseParams(optionalParams, true);
+		this.reportFailure("error", this.withContext(context, () => message instanceof Error ? this.logger.error(message, data) : this.logger.error(this.formatMessage(message), data)));
+	}
+	/**
+	* NestJS `LoggerService.fatal`. logixia has no level above `error`, so this logs
+	* at `error` with `fatal: true` in the payload, or at a custom `fatal` level when
+	* one is configured.
+	*
+	* @example `logger.fatal('Cannot reach the database, shutting down', 'Bootstrap')`
+	*/
+	fatal(message, ...optionalParams) {
+		var _this$_mergedConfig$l2;
+		const { context, data } = this.parseParams(optionalParams, true);
+		const text = this.formatMessage(message);
+		const hasFatalLevel = ((_this$_mergedConfig$l2 = this._mergedConfig.levelOptions) === null || _this$_mergedConfig$l2 === void 0 || (_this$_mergedConfig$l2 = _this$_mergedConfig$l2.levels) === null || _this$_mergedConfig$l2 === void 0 ? void 0 : _this$_mergedConfig$l2["fatal"]) !== void 0;
+		this.reportFailure("fatal", this.withContext(context, () => hasFatalLevel ? this.logger.logLevel("fatal", text, data) : this.logger.error(text, {
+			...data,
+			fatal: true
+		})));
 	}
-	warn(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.warn(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.warn(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.warn failed", err));
+	warn(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) return this.logger.warn(this.formatMessage(message), only);
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("warn", this.withContext(context, () => this.logger.warn(this.formatMessage(message), data)));
 	}
-	debug(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.debug(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.debug(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.debug failed", err));
+	debug(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) return this.logger.debug(this.formatMessage(message), only);
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("debug", this.withContext(context, () => this.logger.debug(this.formatMessage(message), data)));
 	}
-	verbose(message, dataOrContext) {
-		if (typeof dataOrContext === "object" && dataOrContext !== null) return this.logger.trace(this.formatMessage(message), dataOrContext);
-		this.setContextIfProvided(typeof dataOrContext === "string" ? dataOrContext : void 0);
-		this.logger.trace(this.formatMessage(message)).catch((err) => internalError("LogixiaLoggerService.verbose failed", err));
+	verbose(message, ...optionalParams) {
+		const only = optionalParams[0];
+		if (optionalParams.length === 1 && typeof only === "object" && only !== null) return this.logger.trace(this.formatMessage(message), only);
+		const { context, data } = this.parseParams(optionalParams);
+		this.reportFailure("verbose", this.withContext(context, () => this.logger.trace(this.formatMessage(message), data)));
 	}
 	/**
 	* Native async `trace` — lowest verbosity level, structured data.
@@ -153,9 +207,30 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	getLevel() {
 		return this.logger.getLevel();
 	}
+	/**
+	* NestJS `LoggerService.setLogLevels`. logixia filters by a minimum level, not a
+	* set, so the most verbose of `levels` becomes the threshold and everything more
+	* severe stays on (`['log', 'error']` also enables `warn`). Unknown names are
+	* ignored, and an empty list is ignored too: use `silent` to turn logging off.
+	*
+	* @example `logger.setLogLevels(['error', 'warn'])`
+	*/
+	setLogLevels(levels) {
+		let threshold;
+		let verbosity = -1;
+		for (const name of levels) {
+			const level = NEST_LEVEL_TO_LOGIXIA[name];
+			const rank = level === void 0 ? -1 : LEVEL_VERBOSITY.indexOf(level);
+			if (rank > verbosity) {
+				verbosity = rank;
+				threshold = level;
+			}
+		}
+		if (threshold !== void 0) this.setLevel(threshold);
+	}
 	child(context, data) {
-		const childService = new _LogixiaLoggerService(this._mergedConfig);
-		childService.logger = this.logger.child(context, data);
+		const childService = Object.create(_LogixiaLoggerService.prototype);
+		childService._attach(this._mergedConfig, this.logger.child(context, data));
 		childService.context = context;
 		return childService;
 	}
@@ -175,12 +250,62 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 	getLogger() {
 		return this.logger;
 	}
-	setContextIfProvided(context) {
-		if (typeof context !== "string" || context.length === 0) return;
-		if (context !== this.context) this.setContext(context);
+	withContext(context, fn) {
+		if (context === void 0 || context === this.logger.getContext()) return fn();
+		const previous = this.logger.getContext() ?? "";
+		this.logger.setContext(context);
+		try {
+			return fn();
+		} finally {
+			this.logger.setContext(previous);
+		}
+	}
+	/**
+	* Split NestJS `...optionalParams` into a per-call context and a payload.
+	* A trailing string is the context; plain objects are merged into the payload and
+	* an Error goes under `error`. For `error()` (`withStack`), a leading string is the stack
+	* trace, and a lone string is the stack only if it looks like one, since Nest's own
+	* `Logger` appends the context as the last param. Anything else is listed under `params`.
+	*/
+	parseParams(params, withStack = false) {
+		if (params.length === 0) return {};
+		let rest = params;
+		let context;
+		const last = params[params.length - 1];
+		if (typeof last === "string" && !(withStack && params.length === 1 && looksLikeStack(last))) {
+			context = last.length > 0 ? last : void 0;
+			rest = params.slice(0, -1);
+		}
+		let data;
+		const extras = [];
+		for (const param of rest) if (withStack && typeof param === "string" && (data === null || data === void 0 ? void 0 : data["stack"]) === void 0) data = {
+			...data,
+			stack: param
+		};
+		else if (param instanceof Error) data = {
+			...data,
+			error: param
+		};
+		else if (isPlainObject(param)) data = {
+			...data,
+			...param
+		};
+		else if (param !== void 0) extras.push(typeof param === "object" && param !== null ? describeObject(param) : param);
+		if (extras.length > 0) data = {
+			...data,
+			params: extras
+		};
+		return context === void 0 ? { data } : {
+			context,
+			data
+		};
+	}
+	reportFailure(method, result) {
+		result.catch((err) => internalError(`LogixiaLoggerService.${method} failed`, err));
 	}
 	formatMessage(message) {
 		if (typeof message === "string") return message;
+		if (message !== null && typeof message === "object") return message;
 		return safeToString(message);
 	}
 };
@@ -191,12 +316,24 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor {
 	static {
 		_KafkaTraceInterceptor = this;
 	}
+	requireTraceId;
+	/**
+	* Process-wide counters. Readable from anywhere — scrape into your metrics
+	* system (Prometheus, Datadog, CloudWatch) on an interval.
+	*/
+	static metrics = {
+		accepted: 0,
+		acceptedWithoutTrace: 0,
+		dropped: 0
+	};
 	/** Reset counters (tests). */
 	static resetMetrics() {
 		_KafkaTraceInterceptor.metrics.accepted = 0;
 		_KafkaTraceInterceptor.metrics.acceptedWithoutTrace = 0;
 		_KafkaTraceInterceptor.metrics.dropped = 0;
 	}
+	ctx = TraceContext.instance;
+	config;
 	/**
 	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
 	* @param requireTraceId - When true, messages with no traceId are silently skipped
@@ -207,7 +344,6 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor {
 	*/
 	constructor(config, requireTraceId = false) {
 		this.requireTraceId = requireTraceId;
-		this.ctx = TraceContext.instance;
 		this.config = {
 			enabled: true,
 			contextKey: "traceId",
@@ -266,11 +402,6 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor {
 			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
 		});
 	}
-	static #_ = () => this.metrics = {
-		accepted: 0,
-		acceptedWithoutTrace: 0,
-		dropped: 0
-	};
 };
 KafkaTraceInterceptor = _KafkaTraceInterceptor = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
 // \0@oxc-project+runtime@0.155.0/helpers/esm/decorateParam.js
@@ -311,9 +442,11 @@ function traceUrl(req, names) {
 	return raw === void 0 ? void 0 : redactUrlQuery(raw, names);
 }
 let TraceMiddleware = class TraceMiddleware {
+	config;
+	ctx = TraceContext.instance;
+	redactParams;
 	constructor(config, redactQueryParams) {
 		this.config = config;
-		this.ctx = TraceContext.instance;
 		this.redactParams = buildNameSet(DEFAULT_REDACT_QUERY_PARAMS, redactQueryParams);
 		const defaultExtractor = {
 			header: DEFAULT_TRACE_HEADERS,
@@ -362,8 +495,9 @@ TraceMiddleware = __decorate([
 ], TraceMiddleware);
 // src/core/websocket-trace.interceptor.ts
 let WebSocketTraceInterceptor = class WebSocketTraceInterceptor {
+	ctx = TraceContext.instance;
+	config;
 	constructor(config) {
-		this.ctx = TraceContext.instance;
 		this.config = {
 			enabled: true,
 			contextKey: "traceId",
@@ -432,9 +566,14 @@ let LogixiaLoggerModule = class LogixiaLoggerModule {
 	static {
 		_LogixiaLoggerModule = this;
 	}
-	constructor() {
-		this.config = {};
-	}
+	config = {};
+	static loggerConfig = {};
+	/**
+	* @internal Backing field for the global logger. Do not read or write
+	* directly — use {@link getGlobalLogger} / {@link _setGlobalLogger} which
+	* enforce single-init semantics.
+	*/
+	static _globalLogger = null;
 	/**
 	* @internal Set the global logger exactly once.
 	*
@@ -674,7 +813,6 @@ let LogixiaLoggerModule = class LogixiaLoggerModule {
 			inject: [options.useExisting || options.useClass]
 		};
 	}
-	static #_ = () => (this.loggerConfig = {}, this._globalLogger = null);
 };
 LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([Module({})], LogixiaLoggerModule);
 // src/core/nestjs-extras.ts
@@ -711,7 +849,7 @@ const InjectLogger = (context) => context === void 0 ? Inject(LogixiaLoggerServi
 * ```
 */
 function LogMethod(options = {}) {
-	const { level = "debug", logArgs = true, logResult = false, logErrors = true } = options;
+	const { level = "debug", logArgs = false, logResult = false, logErrors = true } = options;
 	return function(target, propertyKey, descriptor) {
 		var _constructor;
 		const originalMethod = descriptor.value;
@@ -852,6 +990,10 @@ function sanitizedError(exception, clean) {
 	}
 }
 let LogixiaExceptionFilter = class LogixiaExceptionFilter {
+	_logger;
+	_traceConfig;
+	_options;
+	_redactParams;
 	constructor(logger, loggerConfig, options) {
 		var _loggerConfig$redact;
 		this._options = options ?? {};