logixia 2.0.10 → 2.1.0

package/dist/nest.js

@@ -1,10 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_secret_config = require("./secret-config-BvFl2dC8.js");
-const require_builder = require("./builder-BLIStsCK.js");
-const require_sensitive_names = require("./sensitive-names-CHMowujD.js");
-const require_request_trace = require("./request-trace-ByujsUZk.js");
+const require_secret_config = require("./secret-config--cVTOWwp.js");
+const require_builder = require("./builder-jMlVYaQa.js");
+const require_own_property = require("./own-property-BWkibepN.js");
+const require_request_trace = require("./request-trace-C7kXMjx5.js");
+const require_sensitive_names = require("./sensitive-names-NiKIRhp5.js");
 const require_internal_log = require("./internal-log-DwqTjhpb.js");
-const require_coerce_utils = require("./coerce.utils-C1C5sIX0.js");
+const require_csv_utils = require("./csv.utils-CbVHY1pd.js");
 let _nestjs_common = require("@nestjs/common");
 let rxjs = require("rxjs");
 // \0@oxc-project+runtime@0.155.0/helpers/esm/decorateMetadata.js
@@ -20,9 +21,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: require_builder.LogLevel.ERROR,
+	error: require_builder.LogLevel.ERROR,
+	warn: require_builder.LogLevel.WARN,
+	log: require_builder.LogLevel.INFO,
+	debug: require_builder.LogLevel.DEBUG,
+	verbose: require_builder.LogLevel.TRACE
+};
+const LEVEL_VERBOSITY = [
+	require_builder.LogLevel.ERROR,
+	require_builder.LogLevel.WARN,
+	require_builder.LogLevel.INFO,
+	require_builder.LogLevel.DEBUG,
+	require_builder.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) ? require_csv_utils.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,
@@ -57,37 +86,40 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 				message: "[message]",
 				payload: "[payload]",
 				timeTaken: "[time_taken_MS]"
-			}
-		};
-		require_secret_config.protectSecrets(this, ["_mergedConfig"]);
-		this._mergedConfig = {
-			...defaultConfig,
+			},
 			...config
 		};
-		this.logger = new require_builder.LogixiaLogger(this._mergedConfig);
+		this._attach(mergedConfig, new require_builder.LogixiaLogger(mergedConfig));
+	}
+	_attach(mergedConfig, logger) {
+		require_secret_config.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) => require_internal_log.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>`.
@@ -97,27 +129,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) => require_internal_log.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) => require_internal_log.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) => require_internal_log.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) => require_internal_log.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.
@@ -141,7 +195,7 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService {
 		return this.logger.timeAsync(label, fn);
 	}
 	setContext(context) {
-		const coerced = typeof context === "string" ? context : require_coerce_utils.safeToString(context);
+		const coerced = typeof context === "string" ? context : require_csv_utils.safeToString(context);
 		this.context = coerced;
 		this.logger.setContext(coerced);
 	}
@@ -154,9 +208,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;
 	}
@@ -176,13 +251,63 @@ 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) => require_internal_log.internalError(`LogixiaLoggerService.${method} failed`, err));
 	}
 	formatMessage(message) {
 		if (typeof message === "string") return message;
-		return require_coerce_utils.safeToString(message);
+		if (message !== null && typeof message === "object") return message;
+		return require_csv_utils.safeToString(message);
 	}
 };
 LogixiaLoggerService = _LogixiaLoggerService = __decorate([(0, _nestjs_common.Injectable)({ scope: _nestjs_common.Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
@@ -192,12 +317,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 = require_request_trace.TraceContext.instance;
+	config;
 	/**
 	* @param config        - TraceIdConfig options (extractor keys, contextKey, etc.)
 	* @param requireTraceId - When true, messages with no traceId are silently skipped
@@ -208,7 +345,6 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor {
 	*/
 	constructor(config, requireTraceId = false) {
 		this.requireTraceId = requireTraceId;
-		this.ctx = require_request_trace.TraceContext.instance;
 		this.config = {
 			enabled: true,
 			contextKey: "traceId",
@@ -267,11 +403,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([(0, _nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [Object, Boolean])], KafkaTraceInterceptor);
 // \0@oxc-project+runtime@0.155.0/helpers/esm/decorateParam.js
@@ -312,9 +443,11 @@ function traceUrl(req, names) {
 	return raw === void 0 ? void 0 : require_sensitive_names.redactUrlQuery(raw, names);
 }
 let TraceMiddleware = class TraceMiddleware {
+	config;
+	ctx = require_request_trace.TraceContext.instance;
+	redactParams;
 	constructor(config, redactQueryParams) {
 		this.config = config;
-		this.ctx = require_request_trace.TraceContext.instance;
 		this.redactParams = require_sensitive_names.buildNameSet(require_sensitive_names.DEFAULT_REDACT_QUERY_PARAMS, redactQueryParams);
 		const defaultExtractor = {
 			header: require_request_trace.DEFAULT_TRACE_HEADERS,
@@ -363,8 +496,9 @@ TraceMiddleware = __decorate([
 ], TraceMiddleware);
 // src/core/websocket-trace.interceptor.ts
 let WebSocketTraceInterceptor = class WebSocketTraceInterceptor {
+	ctx = require_request_trace.TraceContext.instance;
+	config;
 	constructor(config) {
-		this.ctx = require_request_trace.TraceContext.instance;
 		this.config = {
 			enabled: true,
 			contextKey: "traceId",
@@ -433,9 +567,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.
 	*
@@ -675,7 +814,6 @@ let LogixiaLoggerModule = class LogixiaLoggerModule {
 			inject: [options.useExisting || options.useClass]
 		};
 	}
-	static #_ = () => (this.loggerConfig = {}, this._globalLogger = null);
 };
 LogixiaLoggerModule = _LogixiaLoggerModule = __decorate([(0, _nestjs_common.Module)({})], LogixiaLoggerModule);
 // src/core/nestjs-extras.ts
@@ -712,7 +850,7 @@ const InjectLogger = (context) => context === void 0 ? (0, _nestjs_common.Inject
 * ```
 */
 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;
@@ -806,7 +944,7 @@ function scrubSerialized(value, clean, depth, seen) {
 	try {
 		if (Array.isArray(value)) return value.map((item) => scrubSerialized(item, clean, depth + 1, seen));
 		const out = {};
-		for (const [key, item] of Object.entries(value)) require_sensitive_names.assignOwn(out, key, scrubSerialized(item, clean, depth + 1, seen));
+		for (const [key, item] of Object.entries(value)) require_own_property.assignOwn(out, key, scrubSerialized(item, clean, depth + 1, seen));
 		return out;
 	} finally {
 		seen.delete(value);
@@ -824,7 +962,7 @@ function fallbackError(exception, clean) {
 	} catch {}
 	const copy = new Error(message);
 	copy.name = name;
-	require_sensitive_names.assignOwn(copy, "serialization", "[Unserializable]");
+	require_own_property.assignOwn(copy, "serialization", "[Unserializable]");
 	return copy;
 }
 /**
@@ -845,7 +983,7 @@ function sanitizedError(exception, clean) {
 				writable: true,
 				configurable: true
 			});
-			else require_sensitive_names.assignOwn(copy, key, value);
+			else require_own_property.assignOwn(copy, key, value);
 		}
 		return copy;
 	} catch {
@@ -853,6 +991,10 @@ function sanitizedError(exception, clean) {
 	}
 }
 let LogixiaExceptionFilter = class LogixiaExceptionFilter {
+	_logger;
+	_traceConfig;
+	_options;
+	_redactParams;
 	constructor(logger, loggerConfig, options) {
 		var _loggerConfig$redact;
 		this._options = options ?? {};