logixia 1.13.0 → 2.0.0

package/dist/{transport.manager-D6KL3t9V.mjs → transport.manager-BiuCAJd2.mjs}

@@ -1,14 +1,33 @@
 import { t as __require } from "./chunk-DLSkYcPk.mjs";
 import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
 import { i as stringifyForLog } from "./safe-stringify-DJ66tW5I.mjs";
-import { t as safeToString } from "./coerce.utils-Dxv4_ikC.mjs";
+import { t as mergeCoreFields } from "./entry-fields-BJkuPnIg.mjs";
+import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import { EventEmitter } from "node:events";
-import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
-import { createGzip } from "node:zlib";
+import { createGzip, gzip } from "node:zlib";
+import { pipeline } from "node:stream/promises";
 
+//#region src/utils/sanitize.utils.ts
+/**
+* Control-character stripping for text-mode log output.
+*
+* Line breaks become the visible escapes `\\n` / `\\r`; other C0 characters
+* (except tab), DEL and C1 characters are removed, so user-supplied text cannot
+* inject ANSI escapes, overwrite lines, or forge extra log entries.
+*/
+const CONTROL_CHARS_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]/g;
+const VISIBLE_ESCAPES = {
+	"\n": "\\n",
+	"\r": "\\r"
+};
+function stripControlChars(value) {
+	return value.replace(CONTROL_CHARS_RE, (ch) => VISIBLE_ESCAPES[ch] ?? "");
+}
+
+//#endregion
 //#region src/transports/console.transport.ts
 /**
 * Writes log entries to stdout (info/debug/verbose) and stderr (error/warn).
@@ -39,9 +58,8 @@ var ConsoleTransport = class ConsoleTransport {
 		["brightwhite", "\x1B[97m"],
 		["reset", "\x1B[0m"]
 	]);
-	static #_2 = this.CONTROL_CHARS_RE = /[\x00-\x08\x0B-\x1F\x7F-\x9F]/g;
 	static sanitize(value) {
-		return safeToString(value).replace(ConsoleTransport.CONTROL_CHARS_RE, "");
+		return stripControlChars(safeToString(value));
 	}
 	constructor(config = {}) {
 		this.config = config;
@@ -54,16 +72,15 @@ var ConsoleTransport = class ConsoleTransport {
 		(lvl === "error" || lvl === "warn" ? process.stderr : process.stdout).write(formatted);
 	}
 	formatEntry(entry) {
-		if (this.config.format === "json") return stringifyForLog({
+		if (this.config.format === "json") return stringifyForLog(mergeCoreFields({
 			timestamp: this.config.timestamp !== false ? entry.timestamp.toISOString() : void 0,
 			level: entry.level,
 			message: entry.message,
-			...entry.data || {},
 			context: entry.context,
 			traceId: entry.traceId,
 			appName: entry.appName,
 			environment: entry.environment
-		});
+		}, entry.data));
 		const parts = [];
 		if (this.config.timestamp !== false) {
 			const timestamp = entry.timestamp.toISOString();
@@ -111,6 +128,47 @@ var ConsoleTransport = class ConsoleTransport {
 	}
 };
 
+//#endregion
+//#region src/transports/buffer-cap.ts
+const DEFAULT_BUFFER_CAP = 1e4;
+const DROP_WARN_INTERVAL_MS$1 = 5e3;
+/**
+* Keeps an in-memory retry buffer bounded. Past `max` the oldest items are
+* dropped, counted, and reported through internalWarn at most every few seconds.
+*
+* `requested` must be an integer of at least 1, otherwise the default is used.
+* A cap below `batchSize` is raised to `batchSize` so one batch always fits.
+*/
+var BufferCap = class {
+	constructor(name, requested, batchSize, fallback = DEFAULT_BUFFER_CAP) {
+		this.name = name;
+		this.dropped = 0;
+		this.lastWarning = 0;
+		let max = fallback;
+		if (requested !== void 0) if (Number.isInteger(requested) && requested >= 1) max = requested;
+		else internalWarn(`${name}: maxBufferSize ${String(requested)} is not a positive integer; using ${fallback}`);
+		this.max = Math.max(max, batchSize);
+	}
+	/** Drops the oldest items beyond the cap, in place. */
+	enforce(items) {
+		const excess = items.length - this.max;
+		if (excess <= 0) return;
+		items.splice(0, excess);
+		this.note(excess);
+	}
+	note(count) {
+		this.dropped += count;
+		this.report(DROP_WARN_INTERVAL_MS$1);
+	}
+	report(minGapMs) {
+		const now = Date.now();
+		if (this.dropped === 0 || now - this.lastWarning < minGapMs) return;
+		internalWarn(`${this.name}: buffer full (${this.max}), dropped ${this.dropped} oldest entr${this.dropped === 1 ? "y" : "ies"}`);
+		this.dropped = 0;
+		this.lastWarning = now;
+	}
+};
+
 //#endregion
 //#region src/transports/database.transport.ts
 /**
@@ -121,6 +179,80 @@ const POSTGRES_MAX_PARAMS = 65535;
 const POSTGRES_COLUMNS = 8;
 const POSTGRES_ROWS_PER_INSERT = Math.floor(POSTGRES_MAX_PARAMS / POSTGRES_COLUMNS);
 const MYSQL_ROWS_PER_INSERT = 5e3;
+/** Postgres rejects NUL in TEXT and JSONB. */
+function stripNul(value) {
+	return typeof value === "string" ? value.split("\0").join("") : value;
+}
+/** JSONB also rejects the \u0000 escape, which JSON.stringify writes for a NUL. */
+function stripJsonNulEscape(value) {
+	if (typeof value !== "string") return value;
+	return value.replace(/(?<!\\)((?:\\\\)*)\\u0000/g, "$1");
+}
+const PG_DATA_CLASSES = [
+	"22",
+	"23",
+	"54"
+];
+const MYSQL_DATA_CODES = new Set([
+	"ER_DATA_TOO_LONG",
+	"ER_TRUNCATED_WRONG_VALUE",
+	"ER_TRUNCATED_WRONG_VALUE_FOR_FIELD",
+	"ER_BAD_NULL_ERROR",
+	"ER_WARN_DATA_OUT_OF_RANGE",
+	"ER_DUP_ENTRY",
+	"ER_INVALID_JSON_TEXT",
+	"ER_INVALID_CHARACTER_STRING"
+]);
+const MYSQL_DATA_ERRNOS = new Set([
+	1048,
+	1062,
+	1264,
+	1292,
+	1366,
+	1406,
+	3140
+]);
+const SQLITE_DATA_CODES = new Set([
+	"SQLITE_CONSTRAINT",
+	"SQLITE_TOOBIG",
+	"SQLITE_MISMATCH"
+]);
+const MONGO_DATA_CODES = new Set([
+	2,
+	121,
+	10334,
+	11e3
+]);
+function isDataErrorLayer(type, e) {
+	const code = e.code;
+	switch (type) {
+		case "postgresql": return typeof code === "string" && PG_DATA_CLASSES.includes(code.slice(0, 2));
+		case "mysql": return typeof code === "string" && MYSQL_DATA_CODES.has(code) || typeof e.errno === "number" && MYSQL_DATA_ERRNOS.has(e.errno);
+		case "sqlite": return typeof code === "string" && (SQLITE_DATA_CODES.has(code) || code.startsWith("SQLITE_CONSTRAINT_"));
+		case "mongodb": return e.name === "BSONObjectTooLarge" || typeof code === "number" && MONGO_DATA_CODES.has(code);
+		default: return false;
+	}
+}
+/**
+* True when the database refused the data itself (bad value, constraint, size),
+* which retrying cannot fix. Connection, timeout, auth and unknown errors are
+* not data errors and must be retried, never dropped.
+*/
+function isDataError(type, error) {
+	let current = error;
+	for (let depth = 0; depth < 3 && current && typeof current === "object"; depth += 1) {
+		if (isDataErrorLayer(type, current)) return true;
+		current = current.cause;
+	}
+	return false;
+}
+/** A write that stored part of a batch: only `remaining` still needs to be written. */
+var PartialWriteError = class extends Error {
+	constructor(message, remaining, cause) {
+		super(message, { cause });
+		this.remaining = remaining;
+	}
+};
 function chunk(items, size) {
 	const chunks = [];
 	for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
@@ -149,6 +281,7 @@ var DatabaseTransport = class {
 		this.isConnected = false;
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
+		this.cap = new BufferCap("DatabaseTransport", config.maxBufferSize, this.batchSize);
 		if (config.filter) this.filter = config.filter;
 		if (config.table) validateSqlIdentifier(config.table, "table");
 		this.setupFlushTimer();
@@ -160,6 +293,7 @@ var DatabaseTransport = class {
 	}
 	addToBatch(entry) {
 		this.batch.push(entry);
+		this.cap.enforce(this.batch);
 	}
 	async flush() {
 		if (!this.flushPromise) this.flushPromise = this.drain().finally(() => {
@@ -168,37 +302,97 @@ var DatabaseTransport = class {
 		await this.flushPromise;
 	}
 	/**
-	* Drains the batch to the database one snapshot at a time. The current batch
-	* is detached SYNCHRONOUSLY before awaiting the write, so entries appended by
-	* concurrent write() calls land in a fresh array and are never written twice.
-	* On write failure the snapshot is restored to the front of the batch for the
-	* next flush cycle and the loop stops, so a persistently failing DB does not
-	* hot-spin retrying the same entries.
+	* Drains the buffer to the database one batch at a time. A batch is detached
+	* SYNCHRONOUSLY before awaiting the write, so entries appended by concurrent
+	* write() calls land in a fresh array and are never written twice.
+	*
+	* A failure that is not a data error (connection, timeout, auth, unknown) puts
+	* the batch back at the front of the buffer, bounded by `maxBufferSize`, and
+	* stops the loop so a down database is not hammered. A data error means the
+	* database refused some entry itself, so that batch alone is split to find and
+	* drop the refused entries; see isolate().
 	*/
 	async drain() {
 		while (this.batch.length > 0) {
-			const entriesToFlush = this.batch;
-			this.batch = [];
+			const entries = this.batch.splice(0, this.batchSize);
 			try {
-				switch (this.config.type) {
-					case "mongodb":
-						await this.flushToMongoDB(entriesToFlush);
-						break;
-					case "postgresql":
-						await this.flushToPostgreSQL(entriesToFlush);
-						break;
-					case "mysql":
-						await this.flushToMySQL(entriesToFlush);
-						break;
-					case "sqlite":
-						await this.flushToSQLite(entriesToFlush);
-						break;
-					default: throw new Error(`Unsupported database type: ${this.config.type}`);
-				}
+				await this.writeEntries(entries);
 			} catch (error) {
 				internalError("Database flush error", error);
-				this.batch.unshift(...entriesToFlush);
-				throw error;
+				if (error instanceof PartialWriteError) {
+					this.requeue(error.remaining);
+					throw error.cause;
+				}
+				if (!isDataError(this.config.type, error)) {
+					this.requeue(entries);
+					throw error;
+				}
+				const state = {
+					budget: 2 * this.batchSize,
+					rejected: 0,
+					requeue: [],
+					stopped: false
+				};
+				await this.isolate(entries, state);
+				if (state.rejected > 0) internalWarn(`DatabaseTransport: dropped ${state.rejected} log entr${state.rejected === 1 ? "y" : "ies"} the database rejected`);
+				this.requeue(state.requeue);
+				if (state.stopped) throw state.error;
+			}
+		}
+	}
+	requeue(entries) {
+		if (entries.length === 0) return;
+		this.batch = entries.concat(this.batch);
+		this.cap.enforce(this.batch);
+	}
+	async writeEntries(entries) {
+		switch (this.config.type) {
+			case "mongodb":
+				await this.flushToMongoDB(entries);
+				break;
+			case "postgresql":
+				await this.flushToPostgreSQL(entries);
+				break;
+			case "mysql":
+				await this.flushToMySQL(entries);
+				break;
+			case "sqlite":
+				await this.flushToSQLite(entries);
+				break;
+			default: throw new Error(`Unsupported database type: ${this.config.type}`);
+		}
+	}
+	/**
+	* `entries` failed with a data error. Splits them in half until the refused
+	* entries are alone and drops those. A write that fails with anything but a
+	* data error, or running out of the per-flush write budget, stops the search:
+	* the entries not yet written go back to the buffer.
+	*/
+	async isolate(entries, state) {
+		if (entries.length === 1) {
+			state.rejected += 1;
+			return;
+		}
+		const mid = Math.ceil(entries.length / 2);
+		for (const half of [entries.slice(0, mid), entries.slice(mid)]) {
+			if (state.stopped || state.budget <= 0) {
+				state.requeue.push(...half);
+				continue;
+			}
+			state.budget -= 1;
+			try {
+				await this.writeEntries(half);
+			} catch (error) {
+				if (error instanceof PartialWriteError) {
+					state.requeue.push(...error.remaining);
+					state.stopped = true;
+					state.error = error.cause;
+				} else if (isDataError(this.config.type, error)) await this.isolate(half, state);
+				else {
+					state.requeue.push(...half);
+					state.stopped = true;
+					state.error = error;
+				}
 			}
 		}
 	}
@@ -323,7 +517,26 @@ var DatabaseTransport = class {
 			appName: entry.appName,
 			environment: entry.environment
 		}));
-		await collection.insertMany(documents);
+		try {
+			await collection.insertMany(documents, { ordered: false });
+		} catch (error) {
+			const raw = error.writeErrors;
+			let list = [];
+			if (Array.isArray(raw)) list = raw;
+			else if (raw) list = [raw];
+			const writeErrors = list;
+			if (writeErrors.length === 0) throw error;
+			const remaining = [];
+			let rejected = 0;
+			for (const writeError of writeErrors) {
+				const entry = typeof writeError.index === "number" ? entries[writeError.index] : void 0;
+				if (!entry) throw error;
+				if (isDataError("mongodb", writeError)) rejected += 1;
+				else remaining.push(entry);
+			}
+			if (rejected > 0) internalWarn(`DatabaseTransport: dropped ${rejected} log entr${rejected === 1 ? "y" : "ies"} the database rejected`);
+			if (remaining.length > 0) throw new PartialWriteError("MongoDB insert partially failed", remaining, error);
+		}
 	}
 	async flushToPostgreSQL(entries) {
 		const tableName = this.config.table || "logs";
@@ -336,7 +549,7 @@ var DatabaseTransport = class {
 			entry.traceId,
 			entry.appName,
 			entry.environment
-		]), POSTGRES_ROWS_PER_INSERT);
+		].map((value, column) => stripNul(column === 3 ? stripJsonNulEscape(value) : value))), POSTGRES_ROWS_PER_INSERT);
 		const insertChunk = async (rows) => {
 			const query = `
       INSERT INTO ${tableName} 
@@ -496,6 +709,7 @@ var DatabaseTransport = class {
 			internalError("Database flush during close failed; entries remain buffered", error);
 		}
 		if (this.batch.length > 0) internalError(`Database transport closing with ${this.batch.length} unflushed log entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
+		this.cap.report(0);
 		if (this.connection) switch (this.config.type) {
 			case "mongodb":
 				await this.connection.close();
@@ -552,6 +766,17 @@ var DatabaseTransport = class {
 
 //#endregion
 //#region src/transports/analytics.transport.ts
+/**
+* Thrown by sendBatch() when part of a batch was already delivered. drain()
+* requeues only `unsent`, so delivered entries are not sent twice.
+*/
+var PartialBatchError = class extends Error {
+	constructor(message, unsent, options) {
+		super(message, options);
+		this.unsent = unsent;
+		this.name = "PartialBatchError";
+	}
+};
 var AnalyticsTransport = class {
 	constructor(name, config) {
 		this.batch = [];
@@ -567,6 +792,7 @@ var AnalyticsTransport = class {
 		this.level = config.level;
 		this.batchSize = this.config.batchSize || 50;
 		this.flushInterval = this.config.flushInterval || 1e4;
+		this.cap = new BufferCap(name, config.maxBufferSize, this.batchSize);
 	}
 	async write(entry) {
 		if (!this.isReady) await this.ensureReady();
@@ -576,6 +802,7 @@ var AnalyticsTransport = class {
 	}
 	addToBatch(entry) {
 		this.batch.push(entry);
+		this.cap.enforce(this.batch);
 		if (this.batch.length >= (this.config.batchSize || 50)) this.flush().catch((err) => internalError(`${this.name} batch flush failed`, err));
 		else if (!this.batchTimer && this.config.flushInterval) {
 			var _this$batchTimer$unre, _this$batchTimer;
@@ -610,7 +837,8 @@ var AnalyticsTransport = class {
 				await this.sendBatch(entriesToSend);
 			} catch (error) {
 				internalError(`Analytics transport ${this.name} flush failed`, error);
-				this.batch.unshift(...entriesToSend);
+				this.batch.unshift(...error instanceof PartialBatchError ? error.unsent : entriesToSend);
+				this.cap.enforce(this.batch);
 				return;
 			}
 		}
@@ -623,25 +851,36 @@ var AnalyticsTransport = class {
 		const MAX_CLOSE_FLUSH_ATTEMPTS = 3;
 		for (let attempt = 0; attempt < MAX_CLOSE_FLUSH_ATTEMPTS && this.batch.length > 0; attempt += 1) await this.flush();
 		if (this.batch.length > 0) internalError(`Analytics transport ${this.name} closing with ${this.batch.length} unflushed entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
+		this.cap.report(0);
 		await this.cleanup();
 	}
 	shouldSkipEntry(entry) {
 		return ["debug", "trace"].includes(entry.level.toLowerCase());
 	}
 	transformEntry(entry) {
-		const transformed = {
+		const core = {
 			timestamp: entry.timestamp.toISOString(),
 			level: entry.level,
 			message: entry.message,
-			...entry.data
+			context: entry.context,
+			traceId: entry.traceId,
+			appName: entry.appName,
+			environment: entry.environment
 		};
-		if (entry.context) transformed.context = entry.context;
-		if (entry.traceId) transformed.traceId = entry.traceId;
-		if (entry.appName) transformed.appName = entry.appName;
-		if (entry.environment) transformed.environment = entry.environment;
+		const transformed = mergeCoreFields(core, entry.data, this.reservedKeys());
+		for (const key of [
+			"context",
+			"traceId",
+			"appName",
+			"environment"
+		]) if (!core[key]) delete transformed[key];
 		if (this.config.customProperties) Object.assign(transformed, this.config.customProperties);
 		return transformed;
 	}
+	/** Provider-specific field names a payload key must not replace. */
+	reservedKeys() {
+		return [];
+	}
 	/**
 	* Runs initialize() once. A bad config (say, a missing API key) fails every
 	* write with the same error instead of an unhandled rejection at startup.
@@ -661,8 +900,71 @@ var AnalyticsTransport = class {
 
 //#endregion
 //#region src/transports/datadog.transport.ts
+const gzipAsync = promisify(gzip);
+const MAX_LOGS_PER_REQUEST = 1e3;
+const MAX_LOGS_PAYLOAD_BYTES = 5e6;
+const MAX_LOG_BYTES = 1e6;
+const MAX_TRUNCATED_MESSAGE_CHARS = 15e4;
+const TRUNCATED_LOG_KEYS = [
+	"ddsource",
+	"ddtags",
+	"hostname",
+	"service",
+	"status",
+	"timestamp",
+	"level",
+	"context",
+	"traceId",
+	"appName",
+	"environment",
+	"env",
+	"version",
+	"logger",
+	"dd.trace_id",
+	"dd.span_id"
+];
+const STATUS_MAP = {
+	fatal: "critical",
+	critical: "critical",
+	error: "error",
+	warn: "warn",
+	warning: "warn",
+	info: "info",
+	debug: "debug",
+	trace: "debug",
+	verbose: "debug"
+};
+const MAX_UINT64 = (1n << 64n) - 1n;
+const DASHED_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const HEX = /^[0-9a-f]+$/i;
+const DIGITS = /^\d+$/;
 /**
-* Sends log entries and metrics to Datadog via the Logs and Metrics HTTP APIs.
+* Datadog correlates on a decimal 64-bit id. Accepts:
+* - a dashed UUID (logixia's default trace id): dashes stripped, then 32-hex;
+* - 32 hex chars (W3C trace id) or 16 hex chars containing a-f: low 64 bits as decimal;
+* - an all-digit string: already decimal (dd-trace's native format), passed through.
+* An all-digit string is ambiguous when it is 16 or 32 long: 32 is read as hex (a
+* decimal id has at most 20 digits), 16 is read as decimal.
+* Anything else yields the raw string for trace ids (`passthrough`) and nothing for span ids.
+*/
+function toDatadogId(id, passthrough) {
+	if (typeof id !== "string" || id === "") return void 0;
+	const fallback = passthrough ? id : void 0;
+	const compact = DASHED_UUID.test(id) ? id.replaceAll("-", "") : id;
+	const isHexId = HEX.test(compact) && (compact.length === 32 || compact.length === 16);
+	if (DIGITS.test(compact) && compact.length !== 32) {
+		const value = BigInt(compact);
+		return value <= MAX_UINT64 ? value.toString() : fallback;
+	}
+	if (isHexId) return BigInt(`0x${compact.slice(-16)}`).toString();
+	return fallback;
+}
+/** Datadog tags: no commas or whitespace, lowercase, at most 200 chars. */
+function tag(key, value) {
+	return `${key}:${value}`.replaceAll(/[\s,]+/g, "_").toLowerCase().slice(0, 200);
+}
+/**
+* Sends log entries and metrics to Datadog via the Logs (v2) and Metrics HTTP APIs.
 *
 * The API key is transmitted via the `DD-API-KEY` request header — never in the URL.
 *
@@ -688,29 +990,68 @@ var DataDogTransport = class extends AnalyticsTransport {
 		}
 	}
 	async sendEntry(entry) {
-		const promises = [];
-		if (this.datadogConfig.enableLogs !== false) promises.push(this.sendLog(entry));
-		if (this.datadogConfig.enableMetrics) promises.push(this.sendMetric(entry));
-		if (this.datadogConfig.enableTraces && entry.traceId) promises.push(this.sendTrace(entry));
-		await Promise.all(promises);
+		await this.sendBatch([entry]);
 	}
+	/**
+	* Logs go first, chunk by chunk; metrics follow once every log chunk is out.
+	* A failure part-way throws PartialBatchError naming only the entries that were
+	* not delivered, so a retry never re-posts a chunk Datadog already accepted.
+	*/
 	async sendBatch(entries) {
-		const promises = [];
-		if (this.datadogConfig.enableLogs !== false) promises.push(this.sendLogBatch(entries));
-		if (this.datadogConfig.enableMetrics) promises.push(this.sendMetricBatch(entries));
-		if (this.datadogConfig.enableTraces) {
-			const entriesWithTraces = entries.filter((e) => e.traceId);
-			if (entriesWithTraces.length > 0) promises.push(this.sendTraceBatch(entriesWithTraces));
+		if (this.datadogConfig.enableLogs !== false) await this.sendLogBatch(entries);
+		if (this.datadogConfig.enableMetrics) try {
+			await this.sendMetricBatch(entries);
+		} catch (error) {
+			if (this.datadogConfig.enableLogs === false) throw error;
+			throw new PartialBatchError(error.message, [], { cause: error });
 		}
-		await Promise.all(promises);
 	}
 	async cleanup() {}
-	async sendLog(entry) {
-		await this.sendLogBatch([entry]);
-	}
 	async sendLogBatch(entries) {
-		const payload = { logs: entries.map((entry) => this.transformToDataDogLog(entry)) };
-		await this.makeLogsRequest("/v1/input", payload);
+		const items = entries.map((entry) => ({
+			entry,
+			json: this.serializeLog(entry)
+		}));
+		const chunks = this.chunkLogs(items);
+		for (let i = 0; i < chunks.length; i += 1) {
+			const chunk$1 = chunks[i];
+			try {
+				await this.makeLogsRequest("/api/v2/logs", `[${chunk$1.map((item) => item.json).join(",")}]`);
+			} catch (error) {
+				if (i === 0) throw error;
+				const unsent = chunks.slice(i).flatMap((c) => c.map((item) => item.entry));
+				throw new PartialBatchError(error.message, unsent, { cause: error });
+			}
+		}
+	}
+	/** Splits into requests of at most 1000 entries and about 5MB of JSON. */
+	chunkLogs(items) {
+		const chunks = [];
+		let current = [];
+		let currentBytes = 2;
+		for (const item of items) {
+			const bytes = Buffer.byteLength(item.json) + 1;
+			if (current.length > 0 && (current.length >= MAX_LOGS_PER_REQUEST || currentBytes + bytes > MAX_LOGS_PAYLOAD_BYTES)) {
+				chunks.push(current);
+				current = [];
+				currentBytes = 2;
+			}
+			current.push(item);
+			currentBytes += bytes;
+		}
+		if (current.length > 0) chunks.push(current);
+		return chunks;
+	}
+	/** Serializes once. A log over 1MB keeps its identity and correlation fields but loses its attributes and most of its message. */
+	serializeLog(entry) {
+		const log = this.transformToDataDogLog(entry);
+		const json = stringifyForLog(log);
+		if (Buffer.byteLength(json) <= MAX_LOG_BYTES) return json;
+		const kept = {};
+		for (const key of TRUNCATED_LOG_KEYS) if (log[key] !== void 0) kept[key] = log[key];
+		kept["message"] = String(log["message"]).slice(0, MAX_TRUNCATED_MESSAGE_CHARS);
+		kept["truncated"] = true;
+		return stringifyForLog(kept);
 	}
 	async sendMetric(entry) {
 		await this.sendMetricBatch([entry]);
@@ -719,32 +1060,53 @@ var DataDogTransport = class extends AnalyticsTransport {
 		const payload = { series: entries.map((entry) => this.transformToDataDogMetric(entry)) };
 		await this.makeMetricsRequest("/api/v1/series", payload);
 	}
-	async sendTrace(entry) {
-		await this.sendLog(entry);
-	}
-	async sendTraceBatch(entries) {
-		await this.sendLogBatch(entries);
-	}
 	transformToDataDogLog(entry) {
+		var _entry$data, _entry$data2;
 		const transformed = this.transformEntry(entry);
+		const service = this.datadogConfig.service || "logixia";
+		const env = this.datadogConfig.env || "production";
+		const version = this.datadogConfig.version;
+		const tags = [
+			tag("env", env),
+			tag("service", service),
+			...version ? [tag("version", version)] : []
+		];
+		const spanId = toDatadogId(((_entry$data = entry.data) === null || _entry$data === void 0 ? void 0 : _entry$data["spanId"]) ?? ((_entry$data2 = entry.data) === null || _entry$data2 === void 0 ? void 0 : _entry$data2["span_id"]), false);
+		const traceId = toDatadogId(entry.traceId, true);
 		return {
-			timestamp: entry.timestamp.toISOString(),
-			level: this.mapLogLevel(entry.level),
+			...transformed,
+			ddsource: "nodejs",
+			ddtags: tags.join(","),
+			hostname: this.getHostname(),
+			service,
+			status: this.mapLogLevel(entry.level),
 			message: entry.message,
-			service: this.datadogConfig.service || "logixia",
-			version: this.datadogConfig.version,
-			env: this.datadogConfig.env || "production",
+			env,
+			version,
 			logger: {
 				name: "logixia",
 				thread_name: "main"
 			},
-			...transformed,
-			"dd.trace_id": entry.traceId,
-			"dd.span_id": this.generateSpanId(),
-			host: this.getHostname(),
-			source: "nodejs"
+			...traceId && { "dd.trace_id": traceId },
+			...traceId && spanId && { "dd.span_id": spanId }
 		};
 	}
+	reservedKeys() {
+		return [
+			"status",
+			"ddtags",
+			"ddsource",
+			"hostname",
+			"service",
+			"version",
+			"env",
+			"logger",
+			"host",
+			"source",
+			"dd.trace_id",
+			"dd.span_id"
+		];
+	}
 	transformToDataDogMetric(entry) {
 		return {
 			metric: `logitron.logs.${entry.level}`,
@@ -752,58 +1114,29 @@ var DataDogTransport = class extends AnalyticsTransport {
 			type: "count",
 			host: this.getHostname(),
 			tags: [
-				`level:${entry.level}`,
-				`service:${this.datadogConfig.service || "logixia"}`,
-				`env:${this.datadogConfig.env || "production"}`,
-				...entry.context ? [`context:${entry.context}`] : [],
-				...entry.appName ? [`app:${entry.appName}`] : []
+				tag("level", entry.level),
+				tag("service", this.datadogConfig.service || "logixia"),
+				tag("env", this.datadogConfig.env || "production"),
+				...entry.context ? [tag("context", entry.context)] : [],
+				...entry.appName ? [tag("app", entry.appName)] : []
 			]
 		};
 	}
-	transformToDataDogTrace(entry) {
-		return {
-			trace_id: entry.traceId,
-			span_id: this.generateSpanId(),
-			parent_id: null,
-			name: "log.entry",
-			service: this.datadogConfig.service || "logixia",
-			resource: entry.message,
-			type: "log",
-			start: entry.timestamp.getTime() * 1e6,
-			duration: 1e6,
-			meta: {
-				"log.level": entry.level,
-				"log.message": entry.message,
-				...entry.context && { "log.context": entry.context },
-				...entry.data && Object.keys(entry.data).reduce((acc, key) => {
-					acc[`log.${key}`] = String(entry.data[key]);
-					return acc;
-				}, {})
-			},
-			metrics: { _sampling_priority_v1: 1 }
-		};
-	}
 	mapLogLevel(level) {
-		return {
-			error: "error",
-			warn: "warn",
-			warning: "warn",
-			info: "info",
-			debug: "debug",
-			trace: "trace",
-			verbose: "debug"
-		}[level.toLowerCase()] || "info";
-	}
-	async makeLogsRequest(endpoint, data) {
+		return STATUS_MAP[level.toLowerCase()] || "info";
+	}
+	async makeLogsRequest(endpoint, json) {
 		const url = `${this.logsUrl}${endpoint}`;
 		try {
+			const compress = this.datadogConfig.compress === true;
 			const response = await fetch(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
-					"DD-API-KEY": this.datadogConfig.apiKey
+					"DD-API-KEY": this.datadogConfig.apiKey,
+					...compress && { "Content-Encoding": "gzip" }
 				},
-				body: stringifyForLog(data)
+				body: compress ? await gzipAsync(json) : json
 			});
 			if (!response.ok) throw new Error(`DataDog Logs API error: ${response.status} ${response.statusText}`);
 		} catch (error) {
@@ -826,9 +1159,6 @@ var DataDogTransport = class extends AnalyticsTransport {
 			throw new Error(`Failed to send metrics to DataDog: ${error.message}`, { cause: error });
 		}
 	}
-	generateSpanId() {
-		return Math.floor(Math.random() * 0xffffffffffff).toString(16);
-	}
 	getHostname() {
 		try {
 			return __require("node:os").hostname();
@@ -884,6 +1214,12 @@ const unlink = promisify(fs.unlink);
 const readdir = promisify(fs.readdir);
 const stat = promisify(fs.stat);
 const DROP_WARN_INTERVAL_MS = 5e3;
+const DEFAULT_MAX_QUEUE = 1e4;
+const DEFAULT_FILE_MODE = 384;
+const DEFAULT_DIR_MODE = 448;
+function csvField(value) {
+	return `"${stripControlChars(safeToString(value)).replace(/"/g, "\"\"")}"`;
+}
 const SIZE_UNITS = {
 	"": 1,
 	k: 1024,
@@ -919,6 +1255,10 @@ function formatDatePattern(date, pattern) {
 * rotated files are renamed beside it (`app-2026-10-22T09-30-00-000.log`).
 * With a `rotation` block every file, the live one included, is timestamped.
 *
+* Files are created with mode 0o600 and directories with 0o700; override with
+* `fileMode` and `dirMode`. At most `maxQueue` (default 10000) entries wait in
+* memory; the rest are dropped per `queuePolicy` and counted in a warning.
+*
 * @example
 * transports: { file: { filename: 'app.log', dirname: './logs', maxSize: '50MB' } }
 */
@@ -953,8 +1293,10 @@ var FileTransport = class {
 		this.maxBytes = parseSize(rawMaxSize);
 		if (rawMaxSize !== void 0 && this.maxBytes === void 0) internalWarn(`FileTransport: maxSize ${JSON.stringify(rawMaxSize)} is not a valid size (try '50MB'); size rotation is off`);
 		const maxQueue = config.maxQueue;
-		if (maxQueue !== void 0 && !(Number.isInteger(maxQueue) && maxQueue > 0)) internalWarn(`FileTransport: maxQueue ${String(maxQueue)} is not a positive integer; ignored`);
-		else this.maxQueue = maxQueue;
+		if (maxQueue !== void 0 && !(Number.isInteger(maxQueue) && maxQueue > 0)) internalWarn(`FileTransport: maxQueue ${String(maxQueue)} is not a positive integer; using ${DEFAULT_MAX_QUEUE}`);
+		this.maxQueue = maxQueue !== void 0 && Number.isInteger(maxQueue) && maxQueue > 0 ? maxQueue : DEFAULT_MAX_QUEUE;
+		this.fileMode = config.fileMode ?? DEFAULT_FILE_MODE;
+		this.dirMode = config.dirMode ?? DEFAULT_DIR_MODE;
 		this.queuePolicy = config.queuePolicy ?? "drop-oldest";
 		this.maxFiles = (rotation === null || rotation === void 0 ? void 0 : rotation.maxFiles) ?? config.maxFiles;
 		this.compress = (rotation === null || rotation === void 0 ? void 0 : rotation.compress) ?? config.zippedArchive ?? false;
@@ -964,7 +1306,10 @@ var FileTransport = class {
 		this.ext = path$1.extname(config.filename);
 		this.base = path$1.basename(config.filename, this.ext);
 		try {
-			fs.mkdirSync(this.dir, { recursive: true });
+			fs.mkdirSync(this.dir, {
+				recursive: true,
+				mode: this.dirMode
+			});
 		} catch (error) {
 			internalError(`FileTransport could not create ${this.dir}`, error);
 		}
@@ -1032,7 +1377,7 @@ var FileTransport = class {
 		this.enqueued += 1;
 	}
 	queueFull() {
-		return this.maxQueue !== void 0 && this.batch.length + this.inFlight >= this.maxQueue;
+		return this.batch.length + this.inFlight >= this.maxQueue;
 	}
 	roomAvailable() {
 		const room = new Promise((resolve) => this.spaceWaiters.push(resolve));
@@ -1112,30 +1457,26 @@ var FileTransport = class {
 	}
 	formatEntry(entry) {
 		switch (this.config.format) {
-			case "json": return stringifyForLog({
+			case "json": return stringifyForLog(mergeCoreFields({
 				timestamp: entry.timestamp.toISOString(),
 				level: entry.level,
-				message: entry.message,
-				...entry.data || {}
-			});
-			case "csv": {
-				const safeMessage = safeToString(entry.message);
-				return [
-					entry.timestamp.toISOString(),
-					entry.level,
-					`"${safeMessage.replace(/"/g, "\"\"")}"`,
-					safeToString(entry.context),
-					safeToString(entry.traceId),
-					stringifyForLog(entry.data || {})
-				].join(",");
-			}
+				message: entry.message
+			}, entry.data));
+			case "csv": return [
+				entry.timestamp.toISOString(),
+				csvField(entry.level),
+				csvField(entry.message),
+				csvField(entry.context),
+				csvField(entry.traceId),
+				csvField(stringifyForLog(entry.data || {}))
+			].join(",");
 			case "text":
-			default: return `${entry.timestamp.toISOString()} [${entry.level.toUpperCase()}] ${safeToString(entry.message)}${entry.data ? " " + stringifyForLog(entry.data) : ""}`;
+			default: return `${entry.timestamp.toISOString()} [${stripControlChars(safeToString(entry.level)).toUpperCase()}] ${stripControlChars(safeToString(entry.message))}${entry.data ? " " + stringifyForLog(entry.data) : ""}`;
 		}
 	}
 	addToBatch(entry) {
 		this.enqueue(entry);
-		const threshold = Math.min(this.config.batchSize || 100, this.maxQueue ?? Infinity);
+		const threshold = Math.min(this.config.batchSize || 100, this.maxQueue);
 		if (this.batch.length >= threshold && !this.draining) {
 			if (this.batchTimer) {
 				clearTimeout(this.batchTimer);
@@ -1173,7 +1514,7 @@ var FileTransport = class {
 		if (chunk$1) await this.append(chunk$1, chunkBytes);
 	}
 	async append(content, bytes = Buffer.byteLength(content)) {
-		await appendFile(this.currentFilePath, content);
+		await appendFile(this.currentFilePath, content, { mode: this.fileMode });
 		this.bytesWritten += bytes;
 	}
 	timeToRotate() {
@@ -1267,7 +1608,7 @@ var FileTransport = class {
 	async compressFile(filePath) {
 		const gzPath = `${filePath}.gz`;
 		try {
-			await pipeline(fs.createReadStream(filePath), createGzip(), fs.createWriteStream(gzPath));
+			await pipeline(fs.createReadStream(filePath), createGzip(), fs.createWriteStream(gzPath, { mode: this.fileMode }));
 			await unlink(filePath);
 		} catch (error) {
 			internalError("Failed to compress rotated log file", error);
@@ -1351,12 +1692,27 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 		await this.sendEvents(events);
 	}
 	async cleanup() {}
+	reservedKeys() {
+		return [
+			"event_category",
+			"event_label",
+			"log_level",
+			"log_message",
+			"trace_id",
+			"app_name",
+			"custom_dimension_1",
+			"custom_dimension_2",
+			"custom_dimension_3"
+		];
+	}
 	transformToGAEvent(entry) {
 		const transformed = this.transformEntry(entry);
+		const eventCategory = this.mapLogLevelToCategory(entry.level);
 		return {
 			name: "log_event",
 			params: {
-				event_category: this.mapLogLevelToCategory(entry.level),
+				...this.flattenData(transformed),
+				event_category: eventCategory,
 				event_label: entry.message,
 				log_level: entry.level,
 				log_message: entry.message,
@@ -1365,7 +1721,6 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 				...entry.traceId && { trace_id: entry.traceId },
 				...entry.appName && { app_name: entry.appName },
 				...entry.environment && { environment: entry.environment },
-				...this.flattenData(transformed),
 				custom_dimension_1: entry.level,
 				custom_dimension_2: entry.context || "default",
 				custom_dimension_3: entry.environment || "production"
@@ -1561,12 +1916,21 @@ var MixpanelTransport = class extends AnalyticsTransport {
 		await this.trackEvents(events);
 	}
 	async cleanup() {}
+	reservedKeys() {
+		return [
+			"token",
+			"distinct_id",
+			"time",
+			"$insert_id"
+		];
+	}
 	transformToMixpanelEvent(entry) {
 		const transformed = this.transformEntry(entry);
 		return {
 			name: `log_${entry.level}`,
 			properties: {
 				...transformed,
+				token: this.mixpanelConfig.token,
 				distinct_id: this.mixpanelConfig.distinct_id || "anonymous",
 				time: entry.timestamp.getTime(),
 				$insert_id: this.generateInsertId(entry),
@@ -1579,8 +1943,8 @@ var MixpanelTransport = class extends AnalyticsTransport {
 		const payload = {
 			event: event.name,
 			properties: {
-				token: this.mixpanelConfig.token,
-				...event.properties
+				...event.properties,
+				token: this.mixpanelConfig.token
 			}
 		};
 		await this.makeRequest("/track", [payload]);
@@ -1589,8 +1953,8 @@ var MixpanelTransport = class extends AnalyticsTransport {
 		const payload = events.map((event) => ({
 			event: event.name,
 			properties: {
-				token: this.mixpanelConfig.token,
-				...event.properties
+				...event.properties,
+				token: this.mixpanelConfig.token
 			}
 		}));
 		await this.makeRequest("/track", payload);
@@ -1648,11 +2012,11 @@ var MixpanelTransport = class extends AnalyticsTransport {
 		const payload = {
 			event: eventName,
 			properties: {
+				...properties,
+				...this.mixpanelConfig.enableSuperProperties ? this.mixpanelConfig.superProperties : {},
 				token: this.mixpanelConfig.token,
 				distinct_id: this.mixpanelConfig.distinct_id || "anonymous",
-				time: Date.now(),
-				...properties,
-				...this.mixpanelConfig.enableSuperProperties ? this.mixpanelConfig.superProperties : {}
+				time: Date.now()
 			}
 		};
 		await this.makeRequest("/track", [payload]);
@@ -1712,6 +2076,9 @@ var SegmentTransport = class extends AnalyticsTransport {
 		await this.batchTrack(segmentEvents);
 	}
 	async cleanup() {}
+	reservedKeys() {
+		return ["logger"];
+	}
 	transformToSegmentEvent(entry) {
 		const transformed = this.transformEntry(entry);
 		return {
@@ -1721,10 +2088,10 @@ var SegmentTransport = class extends AnalyticsTransport {
 			anonymousId: this.generateAnonymousId(),
 			timestamp: entry.timestamp.toISOString(),
 			properties: {
+				...transformed,
 				level: entry.level,
 				message: entry.message,
 				logger: "logixia",
-				...transformed,
 				...entry.context && { context: entry.context },
 				...entry.traceId && { traceId: entry.traceId },
 				...entry.appName && { appName: entry.appName },
@@ -1780,11 +2147,10 @@ var SegmentTransport = class extends AnalyticsTransport {
 		}
 	}
 	extractUserId(entry) {
-		if (entry.data) {
-			const d = entry.data;
-			const id = d["userId"] ?? d["user_id"] ?? d["id"];
-			return typeof id === "string" ? id : void 0;
-		}
+		var _entry$data;
+		const field = this.segmentConfig.userIdField ?? "userId";
+		const id = (_entry$data = entry.data) === null || _entry$data === void 0 ? void 0 : _entry$data[field];
+		return typeof id === "string" ? id : void 0;
 	}
 	generateAnonymousId() {
 		return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
@@ -2285,5 +2651,5 @@ var TransportManager = class extends EventEmitter {
 };
 
 //#endregion
-export { FileTransport as a, DatabaseTransport as c, GoogleAnalyticsTransport as i, ConsoleTransport as l, SegmentTransport as n, DataDogTransport as o, MixpanelTransport as r, AnalyticsTransport as s, TransportManager as t };
-//# sourceMappingURL=transport.manager-D6KL3t9V.mjs.map
+export { FileTransport as a, DatabaseTransport as c, stripControlChars as d, GoogleAnalyticsTransport as i, BufferCap as l, SegmentTransport as n, DataDogTransport as o, MixpanelTransport as r, AnalyticsTransport as s, TransportManager as t, ConsoleTransport as u };
+//# sourceMappingURL=transport.manager-BiuCAJd2.mjs.map