logixia 2.0.7 → 2.0.9

package/dist/{builder-CzmM_4Ub.js → builder-Bs0qkfkY.js}

@@ -6,8 +6,6 @@ const require_internal_log = require("./internal-log-DwqTjhpb.js");
 const require_coerce_utils = require("./coerce.utils-C1C5sIX0.js");
 const require_safe_stringify = require("./safe-stringify-CN7icp8S.js");
 const require_otel = require("./otel-ChnVYRLA.js");
-let fast_json_stringify = require("fast-json-stringify");
-fast_json_stringify = require_secret_config.__toESM(fast_json_stringify);
 let node_os = require("node:os");
 // src/types/index.ts
 const LogLevel = {
@@ -195,6 +193,16 @@ const EXTRA_FIELDS = [
 	"port",
 	"type"
 ];
+const SKIPPED_FIELDS = /* @__PURE__ */ new Set([
+	"name",
+	"message",
+	"stack",
+	"cause",
+	"errors",
+	...EXTRA_FIELDS
+]);
+const NO_OPTIONS = Object.freeze({});
+const NO_FIELDS = [];
 /**
 * Serialize an Error into a plain JSON-safe object, including:
 *  - `name`, `message`, `stack`
@@ -203,8 +211,8 @@ const EXTRA_FIELDS = [
 *  - standard Node.js error fields (`code`, `statusCode`, `errno`, …)
 *  - any other enumerable own properties
 */
-function serializeError(error, options = {}) {
-	const { includeStack = true, maxDepth = 5, excludeFields = [] } = options;
+function serializeError(error, options = NO_OPTIONS) {
+	const { includeStack = true, maxDepth = 5, excludeFields = NO_FIELDS } = options;
 	return _serializeError(error, includeStack, maxDepth, excludeFields, 0, /* @__PURE__ */ new WeakSet());
 }
 function _serializeError(error, includeStack, maxDepth, excludeFields, depth, seen) {
@@ -232,16 +240,8 @@ function _serializeError(error, includeStack, maxDepth, excludeFields, depth, se
 	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, 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 = /* @__PURE__ */ new Set([
-		"name",
-		"message",
-		"stack",
-		"cause",
-		"errors",
-		...EXTRA_FIELDS,
-		...excludeFields
-	]);
+	for (const field of EXTRA_FIELDS) if (!excludeFields.includes(field) && errorRecord[field] !== void 0) serialized[field] = errorRecord[field];
+	const skip = excludeFields.length === 0 ? SKIPPED_FIELDS : /* @__PURE__ */ new Set([...SKIPPED_FIELDS, ...excludeFields]);
 	for (const key of Object.getOwnPropertyNames(error)) {
 		if (skip.has(key)) continue;
 		try {
@@ -297,6 +297,61 @@ function serializeValue(value, remainingDepth, seen) {
 function isError(value) {
 	return value instanceof Error || Boolean(value) && typeof value === "object" && "name" in value && "message" in value;
 }
+const MAX_ERROR_SEARCH_DEPTH = 3;
+const MAX_ERROR_SEARCH_NODES = 2e3;
+/**
+* Replaces real Error instances inside a log payload with their serialized form,
+* because JSON output drops an Error's non-enumerable `message` and `stack`. Runs on
+* every log call, so its work is capped and it copies nothing until it finds one.
+* Duck-typed objects are data, and an Error with its own toJSON has already chosen
+* what to show. The caller's objects are never mutated.
+*/
+function serializeNestedErrors(data) {
+	const outerBudget = errorSearchBudget;
+	errorSearchBudget = MAX_ERROR_SEARCH_NODES;
+	try {
+		return walkForErrors(data, MAX_ERROR_SEARCH_DEPTH, void 0, void 0);
+	} finally {
+		errorSearchBudget = outerBudget;
+	}
+}
+let errorSearchBudget = 0;
+const hasOwn = Object.prototype.hasOwnProperty;
+function walkForErrors(value, depth, parent, grandparent) {
+	if (value instanceof Error) return typeof value.toJSON === "function" ? value : serializeError(value);
+	if (depth === 0 || --errorSearchBudget < 0 || value === parent || value === grandparent) return value;
+	let copy;
+	if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+		const item = value[i];
+		if (item === null || typeof item !== "object") continue;
+		const next = walkForErrors(item, depth - 1, value, parent);
+		if (next !== item) {
+			copy ??= value.slice();
+			copy[i] = next;
+		}
+	}
+	else {
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) return value;
+		const record = value;
+		for (const key in record) {
+			if (!hasOwn.call(record, key)) continue;
+			let item;
+			try {
+				item = record[key];
+			} catch {
+				continue;
+			}
+			if (item === null || typeof item !== "object") continue;
+			const next = walkForErrors(item, depth - 1, record, parent);
+			if (next !== item) {
+				copy ??= { ...record };
+				require_sensitive_names.assignOwn(copy, key, next);
+			}
+		}
+	}
+	return copy ?? value;
+}
 /**
 * Coerce any thrown value into a proper Error instance.
 */
@@ -979,23 +1034,6 @@ function warnOnReservedLevelNames(levels) {
 *  - Feature 4: Cause-chain error serialization (handled in error.utils)
 *  - Feature 5: Adaptive log level based on NODE_ENV / CI detection
 */
-const _fastStringifyEntry = (0, fast_json_stringify.default)({
-	type: "object",
-	properties: {
-		timestamp: { type: "string" },
-		level: { type: "string" },
-		appName: { type: "string" },
-		environment: { type: "string" },
-		message: { type: "string" },
-		context: { type: "string" },
-		traceId: { type: "string" },
-		payload: {
-			type: "object",
-			additionalProperties: true
-		}
-	},
-	additionalProperties: true
-});
 let _tsCacheMs = 0;
 let _tsCacheStr = "";
 function nowIso() {
@@ -1006,6 +1044,39 @@ function nowIso() {
 	}
 	return _tsCacheStr;
 }
+const RESOLVED = Promise.resolve();
+const JSON_STRING_FIELDS = [
+	"timestamp",
+	"level",
+	"appName",
+	"environment",
+	"message",
+	"context",
+	"traceId"
+];
+function toJsonString(value) {
+	if (value === null) return "";
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof RegExp) return value.source;
+	return String(value);
+}
+function toJsonEntry(entry) {
+	const record = entry;
+	let copy;
+	for (const field of JSON_STRING_FIELDS) {
+		const value = record[field];
+		if (value !== void 0 && typeof value !== "string") {
+			copy ??= { ...record };
+			copy[field] = toJsonString(value);
+		}
+	}
+	const payload = entry.payload;
+	if (payload !== void 0 && (payload === null || typeof payload !== "object" || Array.isArray(payload))) {
+		copy ??= { ...record };
+		copy["payload"] = Object.assign({}, payload);
+	}
+	return copy ?? entry;
+}
 function namespacePatternToRegex(pattern) {
 	const escaped = pattern.split(".").map((s) => s === "*" ? "[^.]+" : s.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&")).join("\\.");
 	return new RegExp(`^${escaped}$`);
@@ -1087,6 +1158,11 @@ var LogixiaLogger = class LogixiaLogger {
 		this._hasContextData = false;
 		this._formattedLevels = /* @__PURE__ */ new Map();
 		this._formattedAppName = "";
+		this._jsonHeads = /* @__PURE__ */ new Map();
+		this._jsonHeadsApp = "";
+		this._jsonHeadsEnv = "";
+		this._jsonContextKey = void 0;
+		this._jsonContext = "";
 		this._hasRedact = false;
 		this._nsSeenVersion = 0;
 		this._parent = parent;
@@ -1187,9 +1263,7 @@ var LogixiaLogger = class LogixiaLogger {
 		var _this$config$levelOpt3, _this$config$levelOpt4;
 		warnOnReservedLevelNames((_this$config$levelOpt3 = this.config.levelOptions) === null || _this$config$levelOpt3 === void 0 ? void 0 : _this$config$levelOpt3.levels);
 		if ((_this$config$levelOpt4 = this.config.levelOptions) === null || _this$config$levelOpt4 === void 0 ? void 0 : _this$config$levelOpt4.levels) {
-			for (const levelName of Object.keys(this.config.levelOptions.levels)) if (!this[levelName.toLowerCase()]) this[levelName.toLowerCase()] = async (message, data) => {
-				await this.logLevel(levelName.toLowerCase(), message, data);
-			};
+			for (const levelName of Object.keys(this.config.levelOptions.levels)) if (!this[levelName.toLowerCase()]) this[levelName.toLowerCase()] = (message, data) => this.logLevel(levelName.toLowerCase(), message, data);
 		}
 	}
 	/**
@@ -1291,40 +1365,53 @@ var LogixiaLogger = class LogixiaLogger {
 	* (name, message, stack) under `data.error`; a string is logged as-is.
 	* `data` is merged into the entry payload.
 	*/
-	async error(messageOrError, data) {
-		if (isError(messageOrError)) await this.log("error", messageOrError.message, {
-			...data,
-			error: serializeError(messageOrError)
-		});
-		else await this.log("error", messageOrError, data);
+	error(messageOrError, data) {
+		try {
+			return isError(messageOrError) ? this._run("error", messageOrError.message, {
+				...data,
+				error: serializeError(messageOrError)
+			}) : this._run("error", messageOrError, data);
+		} catch (error) {
+			return Promise.reject(error);
+		}
 	}
 	/** Log `message` at `warn` level; `data` is merged into the entry payload. */
-	async warn(message, data) {
-		await this.log("warn", message, data);
+	warn(message, data) {
+		return this._run("warn", message, data);
 	}
 	/** Log `message` at `info` level; `data` is merged into the entry payload. */
-	async info(message, data) {
-		await this.log("info", message, data);
+	info(message, data) {
+		return this._run("info", message, data);
 	}
 	/** Log `message` at `debug` level; `data` is merged into the entry payload. */
-	async debug(message, data) {
-		await this.log("debug", message, data);
+	debug(message, data) {
+		return this._run("debug", message, data);
 	}
 	/** Log `message` at `trace` level; `data` is merged into the entry payload. */
-	async trace(message, data) {
-		await this.log("trace", message, data);
+	trace(message, data) {
+		return this._run("trace", message, data);
 	}
 	/** Log `message` at `verbose` level; `data` is merged into the entry payload. */
-	async verbose(message, data) {
-		await this.log("verbose", message, data);
+	verbose(message, data) {
+		return this._run("verbose", message, data);
 	}
 	/**
 	* Log at an arbitrary level name, including custom levels. Levels below the
 	* active threshold are dropped, as are level names that are not registered
 	* in `levelOptions.levels` (and are not built-in).
 	*/
-	async logLevel(level, message, data) {
-		await this.log(level, message, data);
+	logLevel(level, message, data) {
+		return this._run(level, message, data);
+	}
+	_run(level, message, data) {
+		try {
+			return this._settle(this.log(level, message, data));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	_settle(out) {
+		return out ?? RESOLVED;
 	}
 	/** Start a named timer; finish it with {@link timeEnd}. Reusing a label restarts it. */
 	time(label) {
@@ -1630,12 +1717,15 @@ var LogixiaLogger = class LogixiaLogger {
 		await this._pluginRegistry.runOnShutdown();
 		deregisterFromShutdown(this);
 	}
-	async log(level, message, data) {
-		if (this.config.silent) return;
+	/** Returns a Promise only when a plugin or a transport is asynchronous. */
+	log(level, message, rawData) {
+		const config = this.config;
+		if (config.silent) return;
 		if (!this.shouldLog(level)) return;
+		const data = rawData instanceof Error ? { error: serializeError(rawData) } : rawData;
 		const alsContext = require_async_context.LogixiaContext.get();
 		let activeTraceId;
-		if (this.config.traceId) {
+		if (config.traceId) {
 			const ctxTraceId = alsContext === null || alsContext === void 0 ? void 0 : alsContext.traceId;
 			activeTraceId = require_request_trace.TraceContext.instance.getCurrentTraceId() ?? (typeof ctxTraceId === "string" ? ctxTraceId : void 0);
 		}
@@ -1643,7 +1733,7 @@ var LogixiaLogger = class LogixiaLogger {
 		const hasAls = alsContext !== void 0 && Object.keys(alsContext).length > 0;
 		const otelFields = require_otel._isOtelBridgeEnabled() ? require_otel._getOtelPayloadIfEnabled() : void 0;
 		const hasOtel = otelFields !== void 0 && Object.keys(otelFields).length > 0;
-		const traceId = this.config.traceId ? activeTraceId ?? this.fallbackTraceId : void 0;
+		const traceId = config.traceId ? activeTraceId ?? this.fallbackTraceId : void 0;
 		let mergedData;
 		if (hasAls) {
 			const als = { ...alsContext };
@@ -1658,14 +1748,19 @@ var LogixiaLogger = class LogixiaLogger {
 			...data
 		};
 		else mergedData = data;
-		const rawPayload = this._hasContextData ? {
+		let rawPayload = this._hasContextData ? {
 			...this.contextData,
 			...mergedData
 		} : mergedData;
+		if (rawPayload) try {
+			rawPayload = serializeNestedErrors(rawPayload);
+		} catch (error) {
+			require_internal_log.internalError("Error serialization failed", error);
+		}
 		let payload;
 		if (rawPayload !== void 0 && rawPayload !== null) {
 			if (this._hasRedact) try {
-				payload = applyRedaction(rawPayload, this.config.redact) ?? rawPayload;
+				payload = applyRedaction(rawPayload, config.redact) ?? rawPayload;
 			} catch (error) {
 				require_internal_log.internalError("Redaction failed", error);
 				payload = { redaction: REDACTION_FAILED };
@@ -1674,7 +1769,7 @@ var LogixiaLogger = class LogixiaLogger {
 		}
 		let safeMessage = message;
 		if (this._hasRedact) try {
-			safeMessage = applyRedactionToString(message, this.config.redact);
+			safeMessage = applyRedactionToString(message, config.redact);
 		} catch (error) {
 			require_internal_log.internalError("Redaction failed", error);
 			safeMessage = REDACTION_FAILED;
@@ -1682,20 +1777,20 @@ var LogixiaLogger = class LogixiaLogger {
 		const entry = {
 			timestamp: nowIso(),
 			level,
-			appName: this.config.appName ?? "App",
-			environment: this.config.environment ?? "development",
+			appName: config.appName ?? "App",
+			environment: config.environment ?? "development",
 			message: safeMessage
 		};
 		if (this.context) entry.context = this.context;
-		if (payload !== void 0) entry.payload = payload;
 		if (traceId !== void 0) entry.traceId = traceId;
-		let finalEntry = entry;
-		if (this._pluginRegistry.size > 0) {
-			finalEntry = await this._pluginRegistry.runOnLog(entry);
-			if (finalEntry === null) return;
-		}
-		const out = this.output(finalEntry, level);
-		if (out !== void 0) await out;
+		if (payload !== void 0) entry.payload = payload;
+		if (this._pluginRegistry.size > 0) return this._logThroughPlugins(entry, level);
+		return this.output(entry, level);
+	}
+	async _logThroughPlugins(entry, level) {
+		const finalEntry = await this._pluginRegistry.runOnLog(entry);
+		if (finalEntry === null) return;
+		await this.output(finalEntry, level);
 	}
 	/**
 	* Hot-path level check: a single Map lookup + integer compare.
@@ -1737,19 +1832,27 @@ var LogixiaLogger = class LogixiaLogger {
 		return this.getLevel();
 	}
 	formatLog(entry) {
-		var _this$config$format2, _this$config$format3, _this$config$format4;
-		if ((_this$config$format2 = this.config.format) === null || _this$config$format2 === void 0 ? void 0 : _this$config$format2.json) try {
-			return _fastStringifyEntry(entry);
-		} catch {
-			return require_safe_stringify.stringifyForLog(entry);
+		const format = this.config.format;
+		if (format === null || format === void 0 ? void 0 : format.json) {
+			if (this._pluginRegistry.size === 0) try {
+				const line = this._buildJsonLine(entry);
+				if (line !== void 0) return line;
+			} catch {}
+			let jsonEntry = entry;
+			try {
+				jsonEntry = toJsonEntry(entry);
+				return JSON.stringify(jsonEntry);
+			} catch {
+				return require_safe_stringify.stringifyForLog(jsonEntry);
+			}
 		}
 		let formatted = "";
-		const doColorize = ((_this$config$format3 = this.config.format) === null || _this$config$format3 === void 0 ? void 0 : _this$config$format3.colorize) ?? true;
+		const doColorize = (format === null || format === void 0 ? void 0 : format.colorize) ?? true;
 		const gray = doColorize ? this._colorMap.get("gray") : "";
 		const cyan = doColorize ? this._colorMap.get("cyan") : "";
 		const yellow = doColorize ? this._colorMap.get("yellow") : "";
 		const reset = doColorize ? this._colorMap.get("reset") : "";
-		if (((_this$config$format4 = this.config.format) === null || _this$config$format4 === void 0 ? void 0 : _this$config$format4.timestamp) !== false && this._fieldCache.get("timestamp") !== false) formatted += `${gray}[${entry.timestamp}]${reset} `;
+		if ((format === null || format === void 0 ? void 0 : format.timestamp) !== false && this._fieldCache.get("timestamp") !== false) formatted += `${gray}[${entry.timestamp}]${reset} `;
 		if (this._fieldCache.get("level") !== false) formatted += this._formattedLevels.get(entry.level) ?? `[${entry.level.toUpperCase()}] `;
 		formatted += this._formattedAppName;
 		if (entry.traceId && this._fieldCache.get("traceId") !== false) formatted += `${cyan}[${require_otel.stripControlChars(String(entry.traceId))}]${reset} `;
@@ -1758,9 +1861,46 @@ var LogixiaLogger = class LogixiaLogger {
 		if (entry.payload !== void 0 && this._fieldCache.get("payload") !== false) formatted += ` ${require_safe_stringify.stringifyForLog(entry.payload)}`;
 		return formatted;
 	}
+	/**
+	* The same bytes JSON.stringify(entry) gives for an entry log() built, without
+	* walking the fixed fields. Returns undefined when a field has an unexpected type.
+	*/
+	_buildJsonLine(entry) {
+		const { timestamp, level, appName, environment, message, context, traceId, payload } = entry;
+		if (typeof timestamp !== "string" || typeof message !== "string" || typeof appName !== "string" || typeof environment !== "string") return;
+		if (appName !== this._jsonHeadsApp || environment !== this._jsonHeadsEnv) {
+			this._jsonHeads.clear();
+			this._jsonHeadsApp = appName;
+			this._jsonHeadsEnv = environment;
+		}
+		let head = this._jsonHeads.get(level);
+		if (head === void 0) {
+			if (typeof level !== "string") return void 0;
+			head = `,"level":${JSON.stringify(level)},"appName":${JSON.stringify(appName)},"environment":${JSON.stringify(environment)},"message":`;
+			this._jsonHeads.set(level, head);
+		}
+		let line = `{"timestamp":"${timestamp}"${head}${JSON.stringify(message)}`;
+		if (context !== void 0) {
+			if (typeof context !== "string") return void 0;
+			if (context !== this._jsonContextKey) {
+				this._jsonContextKey = context;
+				this._jsonContext = `,"context":${JSON.stringify(context)}`;
+			}
+			line += this._jsonContext;
+		}
+		if (traceId !== void 0) {
+			if (typeof traceId !== "string") return void 0;
+			line += `,"traceId":${JSON.stringify(traceId)}`;
+		}
+		if (payload !== void 0) {
+			if (payload === null || typeof payload !== "object" || Array.isArray(payload) || typeof payload.toJSON === "function") return;
+			line += `,"payload":${JSON.stringify(payload)}`;
+		}
+		return `${line}}`;
+	}
 	colorize(text, color) {
-		var _this$config$format5;
-		if (!((_this$config$format5 = this.config.format) === null || _this$config$format5 === void 0 ? void 0 : _this$config$format5.colorize)) return text;
+		var _this$config$format2;
+		if (!((_this$config$format2 = this.config.format) === null || _this$config$format2 === void 0 ? void 0 : _this$config$format2.colorize)) return text;
 		return `${this._colorMap.get(color.toLowerCase()) ?? this._colorMap.get("white")}${text}${this._colorMap.get("reset")}`;
 	}
 	/**
@@ -1812,9 +1952,7 @@ function createLogger(config, context) {
 	const logger = new LogixiaLogger(config, context);
 	const mutableLogger = logger;
 	if ((_config$levelOptions3 = config.levelOptions) === null || _config$levelOptions3 === void 0 ? void 0 : _config$levelOptions3.levels) {
-		for (const levelName of Object.keys(config.levelOptions.levels)) if (!mutableLogger[levelName]) mutableLogger[levelName] = async (message, data) => {
-			await logger.logLevel(levelName, message, data);
-		};
+		for (const levelName of Object.keys(config.levelOptions.levels)) if (!mutableLogger[levelName]) mutableLogger[levelName] = (message, data) => logger.logLevel(levelName, message, data);
 	}
 	return logger;
 }
@@ -2179,6 +2317,12 @@ Object.defineProperty(exports, "serializeError", {
 		return serializeError;
 	}
 });
+Object.defineProperty(exports, "serializeNestedErrors", {
+	enumerable: true,
+	get: function() {
+		return serializeNestedErrors;
+	}
+});
 Object.defineProperty(exports, "usePlugin", {
 	enumerable: true,
 	get: function() {
@@ -2186,4 +2330,4 @@ Object.defineProperty(exports, "usePlugin", {
 	}
 });
 
-//# sourceMappingURL=builder-CzmM_4Ub.js.map
+//# sourceMappingURL=builder-Bs0qkfkY.js.map