logixia 1.10.2 → 1.10.3

package/dist/{logitron-logger.module-bJ1hGhaL.js → logitron-logger.module-Dlf5GwJ9.js}

@@ -1,4 +1,4 @@
-const require_transport_manager = require('./transport.manager-zgEZCJhR.js');
+const require_transport_manager = require('./transport.manager-B9LF9uDd.js');
 let fast_json_stringify = require("fast-json-stringify");
 fast_json_stringify = require_transport_manager.__toESM(fast_json_stringify);
 let node_async_hooks = require("node:async_hooks");
@@ -92,10 +92,10 @@ var PluginRegistry = class {
 	register(plugin) {
 		if (this._plugins.some((p) => p.name === plugin.name)) return;
 		this._plugins.push(plugin);
-		if (plugin.onInit) {
+		if (plugin.onInit) try {
 			const result = plugin.onInit();
 			if (result instanceof Promise) result.catch(() => {});
-		}
+		} catch {}
 	}
 	/** Remove a previously registered plugin by name. No-op if not found. */
 	unregister(name) {
@@ -135,16 +135,20 @@ var PluginRegistry = class {
 	* Errors thrown inside hooks are swallowed to prevent error cascades.
 	*/
 	async runOnError(error, entry) {
-		for (const plugin of this._plugins) if (plugin.onError) {
+		for (const plugin of this._plugins) if (plugin.onError) try {
 			const r = plugin.onError(error, entry);
 			if (r instanceof Promise) await r.catch(() => {});
-		}
+		} catch {}
 	}
 	/** Run all `onShutdown` hooks concurrently. Hook errors are swallowed. */
 	async runOnShutdown() {
 		await Promise.all(this._plugins.filter((p) => Boolean(p.onShutdown)).map((p) => {
-			const r = p.onShutdown();
-			return r instanceof Promise ? r.catch(() => {}) : Promise.resolve();
+			try {
+				const r = p.onShutdown();
+				return r instanceof Promise ? r.catch(() => {}) : Promise.resolve();
+			} catch {
+				return Promise.resolve();
+			}
 		}));
 	}
 };
@@ -248,9 +252,9 @@ function _serializeError(error, includeStack, maxDepth, excludeFields, depth, se
 	if (includeStack && error.stack) serialized.stack = error.stack;
 	const errorWithCause = error;
 	if (errorWithCause.cause !== void 0) if (errorWithCause.cause instanceof Error) serialized.cause = _serializeError(errorWithCause.cause, includeStack, maxDepth, excludeFields, depth + 1, seen);
-	else serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1);
+	else serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1, seen);
 	const aggregateError = error;
-	if (Array.isArray(aggregateError.errors)) serialized.errors = aggregateError.errors.map((e) => e instanceof Error ? _serializeError(e, includeStack, maxDepth, excludeFields, depth + 1, seen) : serializeValue(e, maxDepth - depth - 1));
+	if (Array.isArray(aggregateError.errors)) serialized.errors = aggregateError.errors.map((e) => e instanceof Error ? _serializeError(e, includeStack, maxDepth, excludeFields, depth + 1, seen) : serializeValue(e, maxDepth - depth - 1, seen));
 	const errorRecord = error;
 	for (const field of EXTRA_FIELDS) if (!excludeFields.includes(field) && field in error && errorRecord[field] !== void 0) serialized[field] = errorRecord[field];
 	const skip = new Set([
@@ -266,7 +270,7 @@ function _serializeError(error, includeStack, maxDepth, excludeFields, depth, se
 		if (skip.has(key)) continue;
 		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
 		try {
-			serialized[key] = serializeValue(errorRecord[key], maxDepth - depth - 1);
+			serialized[key] = serializeValue(errorRecord[key], maxDepth - depth - 1, seen);
 		} catch {
 			serialized[key] = "[Unserializable]";
 		}
@@ -275,20 +279,38 @@ function _serializeError(error, includeStack, maxDepth, excludeFields, depth, se
 }
 /**
 * Recursively serialize an arbitrary value to a JSON-safe representation.
+*
+* The `seen` guard is threaded through (not recreated) so cross-referencing
+* errors nested inside plain objects/arrays are caught by the same circular
+* check that protects the top-level error tree, rather than only relying on the
+* depth limit.
 */
-function serializeValue(value, remainingDepth) {
+function serializeValue(value, remainingDepth, seen) {
 	if (remainingDepth <= 0) return "[Max Depth]";
 	if (value === null || value === void 0) return value;
 	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
 	if (value instanceof Date) return value.toISOString();
-	if (value instanceof Error) return _serializeError(value, true, remainingDepth, [], 0, /* @__PURE__ */ new WeakSet());
-	if (Array.isArray(value)) return value.map((item) => serializeValue(item, remainingDepth - 1));
+	if (value instanceof Error) {
+		if (seen.has(value)) return {
+			name: value.name,
+			message: value.message,
+			_circular: true
+		};
+		return _serializeError(value, true, remainingDepth, [], 0, seen);
+	}
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		return value.map((item) => serializeValue(item, remainingDepth - 1, seen));
+	}
 	if (typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
 		const out = {};
 		for (const [k, v] of Object.entries(value)) {
 			if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
 			try {
-				out[k] = serializeValue(v, remainingDepth - 1);
+				out[k] = serializeValue(v, remainingDepth - 1, seen);
 			} catch {
 				out[k] = "[Unserializable]";
 			}
@@ -343,17 +365,21 @@ function tryLoadOtelApi() {
 function getActiveOtelContext(opts = {}) {
 	const api = tryLoadOtelApi();
 	if (!api) return void 0;
-	const ctx = api.context.active();
-	const sc = api.trace.getSpanContext(ctx);
-	if (!sc || !api.trace.isSpanContextValid(sc)) return void 0;
-	const isSampled = (sc.traceFlags & api.trace.TraceFlags.SAMPLED) === api.trace.TraceFlags.SAMPLED;
-	if (opts.sampledOnly && !isSampled) return void 0;
-	return {
-		traceId: sc.traceId,
-		spanId: sc.spanId,
-		traceFlags: sc.traceFlags,
-		isSampled
-	};
+	try {
+		const ctx = api.context.active();
+		const sc = api.trace.getSpanContext(ctx);
+		if (!sc || !api.trace.isSpanContextValid(sc)) return void 0;
+		const isSampled = (sc.traceFlags & api.trace.TraceFlags.SAMPLED) === api.trace.TraceFlags.SAMPLED;
+		if (opts.sampledOnly && !isSampled) return void 0;
+		return {
+			traceId: sc.traceId,
+			spanId: sc.spanId,
+			traceFlags: sc.traceFlags,
+			isSampled
+		};
+	} catch {
+		return;
+	}
 }
 /**
 * Returns a metadata object with OTel context fields ready to merge into a log call,
@@ -588,6 +614,21 @@ function redactObject(obj, config, _currentPath = "") {
 	return result;
 }
 /**
+* Apply pattern-based redaction to a single string (e.g. the log message).
+*
+* Path-based rules don't apply to a bare string — only the `patterns` are run.
+* Returns the input unchanged when no patterns are configured, so the hot path
+* stays allocation-free for the common no-redact case.
+*/
+function applyRedactionToString(value, config) {
+	if (!config) return value;
+	const resolved = resolveConfig(config);
+	if (!resolved.patterns || resolved.patterns.length === 0) return value;
+	let redacted = value;
+	for (const pattern of resolved.patterns) redacted = redacted.replace(pattern, resolved.censor ?? DEFAULT_CENSOR);
+	return redacted;
+}
+/**
 * Apply redaction to a log payload (top-level call convenience wrapper).
 * Returns a new object — never mutates the input.
 */
@@ -612,6 +653,7 @@ var Sampler = class {
 	constructor(config, onStats) {
 		this.sampledTraces = /* @__PURE__ */ new Set();
 		this.droppedTraces = /* @__PURE__ */ new Set();
+		this.maxTrackedTraces = 1e5;
 		this._tokenBucket = 0;
 		this._lastRefillMs = Date.now();
 		this._stats = {
@@ -657,8 +699,8 @@ var Sampler = class {
 				return false;
 			}
 			const emit = this._sampleByRate(lvl);
-			if (emit) this.sampledTraces.add(traceId);
-			else this.droppedTraces.add(traceId);
+			if (emit) this._rememberTrace(this.sampledTraces, traceId);
+			else this._rememberTrace(this.droppedTraces, traceId);
 			if (emit) this._trackEmitted(lvl);
 			else this._trackDropped(lvl);
 			return emit;
@@ -703,6 +745,16 @@ var Sampler = class {
 		if (rate <= 0) return false;
 		return Math.random() < rate;
 	}
+	/**
+	* Record a trace decision, bounding the Set so it can't grow without limit.
+	* If the Set has reached the cap, clear it before inserting — stale decisions
+	* are simply re-made on next sight, which keeps memory bounded at the cost of
+	* occasional re-sampling for very high-cardinality trace workloads.
+	*/
+	_rememberTrace(set, traceId) {
+		if (set.size >= this.maxTrackedTraces) set.clear();
+		set.add(traceId);
+	}
 	_consumeToken() {
 		const now = Date.now();
 		const elapsed = (now - this._lastRefillMs) / 1e3;
@@ -741,6 +793,10 @@ var Sampler = class {
 /** Module-level registry of all logger instances that have opted into graceful shutdown */
 const registry = /* @__PURE__ */ new Set();
 let shutdownHandlerRegistered = false;
+/** Guards the handler against re-entrancy: a second signal (e.g. SIGINT after
+* SIGTERM, or an impatient double Ctrl+C) must not start a second concurrent
+* flush+exit, which could exit the process and truncate the first flush mid-write. */
+let shutdownInProgress = false;
 /** Our own handler + the signals we attached it to, so reset() can detach exactly it. */
 let activeHandler;
 let activeSignals = [];
@@ -772,6 +828,8 @@ function flushOnExit(options = {}) {
 	shutdownHandlerRegistered = true;
 	const { timeout = 5e3, signals = ["SIGTERM", "SIGINT"], beforeFlush, afterFlush } = options;
 	const handler = async (signal) => {
+		if (shutdownInProgress) return;
+		shutdownInProgress = true;
 		const forceExitTimer = setTimeout(() => {
 			process.stderr.write(`[logixia] Graceful shutdown timed out after ${timeout}ms on ${signal}. Force-exiting.\n`);
 			process.exit(1);
@@ -799,6 +857,7 @@ function resetShutdownHandlers() {
 	activeHandler = void 0;
 	activeSignals = [];
 	shutdownHandlerRegistered = false;
+	shutdownInProgress = false;
 }
 
 //#endregion
@@ -1104,7 +1163,11 @@ function createTraceMiddleware(config) {
 		if (resolvedConfig.extractor) traceId = extractTraceId(req, resolvedConfig.extractor);
 		if (!traceId) traceId = resolvedConfig.generator ? resolvedConfig.generator() : generateTraceId();
 		req.traceId = traceId;
-		res.setHeader("X-Trace-Id", traceId);
+		const resObj = res;
+		if (!resObj.headersSent) try {
+			if (typeof resObj.setHeader === "function") resObj.setHeader("X-Trace-Id", traceId);
+			else if (typeof resObj.header === "function") resObj.header("X-Trace-Id", traceId);
+		} catch {}
 		runWithTraceId(traceId, () => next());
 	};
 }
@@ -1586,12 +1649,13 @@ var LogixiaLogger = class LogixiaLogger {
 		let payload;
 		if (rawPayload !== void 0 && rawPayload !== null) payload = this._hasRedact ? applyRedaction(rawPayload, this.config.redact) ?? rawPayload : rawPayload;
 		const traceId = this.config.traceId ? TraceContext.instance.getCurrentTraceId() ?? this.fallbackTraceId : void 0;
+		const safeMessage = this._hasRedact ? applyRedactionToString(message, this.config.redact) : message;
 		const entry = {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			level,
 			appName: this.config.appName ?? "App",
 			environment: this.config.environment ?? "development",
-			message
+			message: safeMessage
 		};
 		if (this.context) entry.context = this.context;
 		if (payload !== void 0) entry.payload = payload;
@@ -1859,8 +1923,7 @@ let LogixiaLoggerService = _LogixiaLoggerService = class LogixiaLoggerService$1
 	}
 	formatMessage(message) {
 		if (typeof message === "string") return message;
-		if (typeof message === "object") return JSON.stringify(message);
-		return String(message);
+		return require_transport_manager.safeToString(message);
 	}
 };
 LogixiaLoggerService = _LogixiaLoggerService = __decorate([(0, __nestjs_common.Injectable)({ scope: __nestjs_common.Scope.TRANSIENT }), __decorateMetadata("design:paramtypes", [Object])], LogixiaLoggerService);
@@ -1943,13 +2006,15 @@ let KafkaTraceInterceptor = class KafkaTraceInterceptor$1 {
 			timestamp: rpcData === null || rpcData === void 0 ? void 0 : rpcData.timestamp
 		};
 		return new rxjs.Observable((subscriber) => {
+			let inner;
 			this.ctx.run(traceId, () => {
-				next.handle().subscribe({
+				inner = next.handle().subscribe({
 					next: (value) => subscriber.next(value),
 					error: (err) => subscriber.error(err),
 					complete: () => subscriber.complete()
 				});
 			}, kafkaContext);
+			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
 		});
 	}
 };
@@ -1977,6 +2042,20 @@ function resolveResponseHeader(config) {
 	if ((config === null || config === void 0 ? void 0 : config.responseHeader) === false) return null;
 	return (config === null || config === void 0 ? void 0 : config.responseHeader) ?? DEFAULT_TRACE_RESPONSE_HEADER;
 }
+/**
+* Echo the trace ID on the response, tolerating non-Express responses and
+* already-sent headers. NestJS can run on Fastify (reply.header() instead of
+* res.setHeader()), and on a closed/sent response setHeader throws — neither
+* should crash the request. The trace ID is still propagated via async context.
+*/
+function writeTraceHeader(res, header, traceId) {
+	const r = res;
+	if (r.headersSent) return;
+	try {
+		if (typeof r.setHeader === "function") r.setHeader(header, traceId);
+		else if (typeof r.header === "function") r.header(header, traceId);
+	} catch {}
+}
 let TraceMiddleware = class TraceMiddleware$1 {
 	constructor(config) {
 		this.config = config;
@@ -1998,7 +2077,7 @@ let TraceMiddleware = class TraceMiddleware$1 {
 		if (this.config.enabled) this.ctx.setContextKey(this.config.contextKey ?? "traceId");
 	}
 	use(req, res, next) {
-		var _this$config;
+		var _this$config, _req$socket, _req$connection;
 		if (!((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enabled)) return next();
 		let traceId;
 		if (this.config.extractor) traceId = extractTraceId(req, this.config.extractor);
@@ -2010,12 +2089,12 @@ let TraceMiddleware = class TraceMiddleware$1 {
 		if (!traceId) traceId = this.ctx.generate();
 		req.traceId = traceId;
 		const header = resolveResponseHeader(this.config);
-		if (header) res.setHeader(header, traceId);
+		if (header) writeTraceHeader(res, header, traceId);
 		this.ctx.run(traceId, () => next(), {
 			method: req.method,
 			url: req.url,
 			userAgent: req.get("User-Agent"),
-			ip: req.ip || req.connection.remoteAddress
+			ip: req.ip || ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) || ((_req$connection = req.connection) === null || _req$connection === void 0 ? void 0 : _req$connection.remoteAddress)
 		});
 	}
 };
@@ -2072,13 +2151,15 @@ let WebSocketTraceInterceptor = class WebSocketTraceInterceptor$1 {
 			clientAddress: client === null || client === void 0 || (_client$handshake3 = client.handshake) === null || _client$handshake3 === void 0 ? void 0 : _client$handshake3.address
 		};
 		return new rxjs.Observable((observer) => {
+			let inner;
 			this.ctx.run(traceId, () => {
-				next.handle().subscribe({
+				inner = next.handle().subscribe({
 					next: (value) => observer.next(value),
 					error: (err) => observer.error(err),
 					complete: () => observer.complete()
 				});
 			}, wsContextData);
+			return () => inner === null || inner === void 0 ? void 0 : inner.unsubscribe();
 		});
 	}
 };
@@ -2619,4 +2700,4 @@ Object.defineProperty(exports, 'usePlugin', {
     return usePlugin;
   }
 });
-//# sourceMappingURL=logitron-logger.module-bJ1hGhaL.js.map
+//# sourceMappingURL=logitron-logger.module-Dlf5GwJ9.js.map