logixia 1.13.3 → 2.0.4

package/dist/{transport.manager-CpdVHEGP.mjs → transport.manager-eZ_EeC00.mjs}

@@ -1,16 +1,16 @@
-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 mergeCoreFields } from "./entry-fields-BJkuPnIg.mjs";
-import { t as safeToString } from "./coerce.utils-Cu6IUTgX.mjs";
+import { t as __require } from "./rolldown-runtime-D3PmRqjj.mjs";
+import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-uCSd1PMc.mjs";
+import { n as protectSecrets, o as urlSecrets, r as scrubError, t as collectSecrets } from "./secret-config-BegMLkYl.mjs";
+import { t as safeToString } from "./coerce.utils-B_rEudCn.mjs";
+import { i as stringifyForLog } from "./safe-stringify-BMRl3EX3.mjs";
+import { t as mergeCoreFields } from "./entry-fields-CGuvT2R0.mjs";
+import { EventEmitter } from "node:events";
+import { promisify } from "node:util";
+import { createGzip, gzip } from "node:zlib";
 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";
-
-//#region src/utils/sanitize.utils.ts
+// src/utils/sanitize.utils.ts
 /**
 * Control-character stripping for text-mode log output.
 *
@@ -26,9 +26,7 @@ const VISIBLE_ESCAPES = {
 function stripControlChars(value) {
 	return value.replace(CONTROL_CHARS_RE, (ch) => VISIBLE_ESCAPES[ch] ?? "");
 }
-
-//#endregion
-//#region src/transports/console.transport.ts
+// src/transports/console.transport.ts
 /**
 * Writes log entries to stdout (info/debug/verbose) and stderr (error/warn).
 *
@@ -38,26 +36,6 @@ function stripControlChars(value) {
 * transports: { console: { format: 'json' } }
 */
 var ConsoleTransport = class ConsoleTransport {
-	static #_ = this.COLORS = new Map([
-		["black", "\x1B[30m"],
-		["red", "\x1B[31m"],
-		["green", "\x1B[32m"],
-		["yellow", "\x1B[33m"],
-		["blue", "\x1B[34m"],
-		["magenta", "\x1B[35m"],
-		["cyan", "\x1B[36m"],
-		["white", "\x1B[37m"],
-		["gray", "\x1B[90m"],
-		["grey", "\x1B[90m"],
-		["brightred", "\x1B[91m"],
-		["brightgreen", "\x1B[92m"],
-		["brightyellow", "\x1B[93m"],
-		["brightblue", "\x1B[94m"],
-		["brightmagenta", "\x1B[95m"],
-		["brightcyan", "\x1B[96m"],
-		["brightwhite", "\x1B[97m"],
-		["reset", "\x1B[0m"]
-	]);
 	static sanitize(value) {
 		return stripControlChars(safeToString(value));
 	}
@@ -126,10 +104,28 @@ var ConsoleTransport = class ConsoleTransport {
 	close() {
 		return Promise.resolve();
 	}
+	static #_ = () => this.COLORS = /* @__PURE__ */ new Map([
+		["black", "\x1B[30m"],
+		["red", "\x1B[31m"],
+		["green", "\x1B[32m"],
+		["yellow", "\x1B[33m"],
+		["blue", "\x1B[34m"],
+		["magenta", "\x1B[35m"],
+		["cyan", "\x1B[36m"],
+		["white", "\x1B[37m"],
+		["gray", "\x1B[90m"],
+		["grey", "\x1B[90m"],
+		["brightred", "\x1B[91m"],
+		["brightgreen", "\x1B[92m"],
+		["brightyellow", "\x1B[93m"],
+		["brightblue", "\x1B[94m"],
+		["brightmagenta", "\x1B[95m"],
+		["brightcyan", "\x1B[96m"],
+		["brightwhite", "\x1B[97m"],
+		["reset", "\x1B[0m"]
+	]);
 };
-
-//#endregion
-//#region src/transports/buffer-cap.ts
+// src/transports/buffer-cap.ts
 const DEFAULT_BUFFER_CAP = 1e4;
 const DROP_WARN_INTERVAL_MS$1 = 5e3;
 /**
@@ -145,8 +141,10 @@ var BufferCap = class {
 		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}`);
+		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. */
@@ -168,9 +166,7 @@ var BufferCap = class {
 		this.lastWarning = now;
 	}
 };
-
-//#endregion
-//#region src/transports/database.transport.ts
+// src/transports/database.transport.ts
 /**
 * Validates that a SQL identifier (table/index name) contains only safe characters.
 * Prevents SQL injection via user-supplied table names.
@@ -193,7 +189,7 @@ const PG_DATA_CLASSES = [
 	"23",
 	"54"
 ];
-const MYSQL_DATA_CODES = new Set([
+const MYSQL_DATA_CODES = /* @__PURE__ */ new Set([
 	"ER_DATA_TOO_LONG",
 	"ER_TRUNCATED_WRONG_VALUE",
 	"ER_TRUNCATED_WRONG_VALUE_FOR_FIELD",
@@ -203,7 +199,7 @@ const MYSQL_DATA_CODES = new Set([
 	"ER_INVALID_JSON_TEXT",
 	"ER_INVALID_CHARACTER_STRING"
 ]);
-const MYSQL_DATA_ERRNOS = new Set([
+const MYSQL_DATA_ERRNOS = /* @__PURE__ */ new Set([
 	1048,
 	1062,
 	1264,
@@ -212,12 +208,12 @@ const MYSQL_DATA_ERRNOS = new Set([
 	1406,
 	3140
 ]);
-const SQLITE_DATA_CODES = new Set([
+const SQLITE_DATA_CODES = /* @__PURE__ */ new Set([
 	"SQLITE_CONSTRAINT",
 	"SQLITE_TOOBIG",
 	"SQLITE_MISMATCH"
 ]);
-const MONGO_DATA_CODES = new Set([
+const MONGO_DATA_CODES = /* @__PURE__ */ new Set([
 	2,
 	121,
 	10334,
@@ -279,6 +275,7 @@ var DatabaseTransport = class {
 		this.name = "database";
 		this.batch = [];
 		this.isConnected = false;
+		protectSecrets(this, ["config", "connection"]);
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
 		this.cap = new BufferCap("DatabaseTransport", config.maxBufferSize, this.batchSize);
@@ -286,6 +283,14 @@ var DatabaseTransport = class {
 		if (config.table) validateSqlIdentifier(config.table, "table");
 		this.setupFlushTimer();
 	}
+	secretValues() {
+		const { connectionString, password } = this.config;
+		return [
+			connectionString,
+			password,
+			...connectionString ? urlSecrets(connectionString) : []
+		];
+	}
 	async write(entry) {
 		if (!this.isConnected) await this.connect();
 		this.addToBatch(entry);
@@ -346,6 +351,13 @@ var DatabaseTransport = class {
 		this.cap.enforce(this.batch);
 	}
 	async writeEntries(entries) {
+		try {
+			await this.writeEntriesUnscrubbed(entries);
+		} catch (error) {
+			throw scrubError(error, this.secretValues());
+		}
+	}
+	async writeEntriesUnscrubbed(entries) {
 		switch (this.config.type) {
 			case "mongodb":
 				await this.flushToMongoDB(entries);
@@ -424,13 +436,12 @@ var DatabaseTransport = class {
 				case "mysql":
 					await this.connectMySQL();
 					break;
-				case "sqlite":
-					await this.connectSQLite();
-					break;
+				case "sqlite": await this.connectSQLite();
 			}
 			this.isConnected = true;
 		} catch (error) {
 			this.isConnected = false;
+			scrubError(error, this.secretValues());
 			throw new Error(`Database connection failed: ${error}`, { cause: error });
 		}
 	}
@@ -439,7 +450,8 @@ var DatabaseTransport = class {
 			const { MongoClient } = await import("mongodb").catch(() => {
 				throw new Error("MongoDB driver not installed. Run: npm install mongodb");
 			});
-			this.connection = new MongoClient(this.config.connectionString || `mongodb://${this.config.host}:${this.config.port}/${this.config.database}`);
+			const connectionString = this.config.connectionString || `mongodb://${this.config.host}:${this.config.port}/${this.config.database}`;
+			this.connection = new MongoClient(connectionString);
 			await this.connection.connect();
 			await this.connection.db(this.config.database).admin().ping();
 		} catch (error) {
@@ -551,12 +563,13 @@ var DatabaseTransport = class {
 			entry.environment
 		].map((value, column) => stripNul(column === 3 ? stripJsonNulEscape(value) : value))), POSTGRES_ROWS_PER_INSERT);
 		const insertChunk = async (rows) => {
+			const placeholders = rows.map((_, i) => {
+				return `(${Array.from({ length: POSTGRES_COLUMNS }, (_unused, c) => `$${i * POSTGRES_COLUMNS + c + 1}`).join(", ")})`;
+			}).join(", ");
 			const query = `
       INSERT INTO ${tableName} 
       (timestamp, level, message, payload, context, trace_id, app_name, environment)
-      VALUES ${rows.map((_, i) => {
-				return `(${Array.from({ length: POSTGRES_COLUMNS }, (_unused, c) => `$${i * POSTGRES_COLUMNS + c + 1}`).join(", ")})`;
-			}).join(", ")}
+      VALUES ${placeholders}
     `;
 			await this.connection.query(query, rows.flat());
 		};
@@ -720,9 +733,7 @@ var DatabaseTransport = class {
 			case "mysql":
 				await this.connection.end();
 				break;
-			case "sqlite":
-				await this.connection.close();
-				break;
+			case "sqlite": await this.connection.close();
 		}
 		this.isConnected = false;
 	}
@@ -763,9 +774,18 @@ var DatabaseTransport = class {
 		}
 	}
 };
-
-//#endregion
-//#region src/transports/analytics.transport.ts
+// 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 = [];
@@ -778,16 +798,25 @@ var AnalyticsTransport = class {
 			enableEventTracking: true,
 			...config
 		};
+		protectSecrets(this, ["config"]);
 		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);
 	}
+	/** Secret strings to scrub from errors: everything secret-looking in the config. Override to add more. */
+	secretValues() {
+		return collectSecrets(this.config);
+	}
 	async write(entry) {
-		if (!this.isReady) await this.ensureReady();
-		if (this.shouldSkipEntry(entry)) return;
-		if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(entry);
-		else await this.sendEntry(entry);
+		try {
+			if (!this.isReady) await this.ensureReady();
+			if (this.shouldSkipEntry(entry)) return;
+			if (this.config.batchSize && this.config.batchSize > 1) this.addToBatch(entry);
+			else await this.sendEntry(entry);
+		} catch (error) {
+			throw scrubError(error, this.secretValues());
+		}
 	}
 	addToBatch(entry) {
 		this.batch.push(entry);
@@ -825,8 +854,9 @@ var AnalyticsTransport = class {
 			try {
 				await this.sendBatch(entriesToSend);
 			} catch (error) {
+				scrubError(error, this.secretValues());
 				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;
 			}
@@ -886,11 +916,72 @@ var AnalyticsTransport = class {
 		await this.ensureReady();
 	}
 };
-
-//#endregion
-//#region src/transports/datadog.transport.ts
+// 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+$/;
+/**
+* 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 and Metrics HTTP APIs.
+* 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.
 *
@@ -905,6 +996,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 		this.baseUrl = `https://api.${site}`;
 		this.logsUrl = `https://http-intake.logs.${site}`;
 		this.metricsUrl = `https://api.${site}`;
+		protectSecrets(this, ["datadogConfig"]);
 	}
 	async initialize() {
 		try {
@@ -916,29 +1008,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 = chunks[i];
+			try {
+				await this.makeLogsRequest("/api/v2/logs", `[${chunk.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]);
@@ -947,29 +1078,35 @@ 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 {
-			...this.transformEntry(entry),
-			"dd.trace_id": entry.traceId,
-			"dd.span_id": this.generateSpanId(),
-			host: this.getHostname(),
-			source: "nodejs",
-			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"
-			}
+			},
+			...traceId && { "dd.trace_id": traceId },
+			...traceId && spanId && { "dd.span_id": spanId }
 		};
 	}
 	reservedKeys() {
@@ -995,58 +1132,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) {
@@ -1069,9 +1177,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();
@@ -1118,9 +1223,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 		}
 	}
 };
-
-//#endregion
-//#region src/transports/file.transport.ts
+// src/transports/file.transport.ts
 const appendFile = promisify(fs.appendFile);
 const rename = promisify(fs.rename);
 const unlink = promisify(fs.unlink);
@@ -1383,7 +1486,6 @@ var FileTransport = class {
 				csvField(entry.traceId),
 				csvField(stringifyForLog(entry.data || {}))
 			].join(",");
-			case "text":
 			default: return `${entry.timestamp.toISOString()} [${stripControlChars(safeToString(entry.level)).toUpperCase()}] ${stripControlChars(safeToString(entry.message))}${entry.data ? " " + stringifyForLog(entry.data) : ""}`;
 		}
 	}
@@ -1409,22 +1511,22 @@ var FileTransport = class {
 			await this.append(content);
 			return;
 		}
-		let chunk$1 = "";
+		let chunk = "";
 		let chunkBytes = 0;
 		for (const entry of entries) {
 			const line = this.formatEntry(entry) + "\n";
 			const lineBytes = Buffer.byteLength(line);
 			const used = this.bytesWritten + chunkBytes;
 			if (used > 0 && used + lineBytes > this.maxBytes) {
-				if (chunk$1) await this.append(chunk$1, chunkBytes);
-				chunk$1 = "";
+				if (chunk) await this.append(chunk, chunkBytes);
+				chunk = "";
 				chunkBytes = 0;
 				await this.rotateFile();
 			}
-			chunk$1 += line;
+			chunk += line;
 			chunkBytes += lineBytes;
 		}
-		if (chunk$1) await this.append(chunk$1, chunkBytes);
+		if (chunk) await this.append(chunk, chunkBytes);
 	}
 	async append(content, bytes = Buffer.byteLength(content)) {
 		await appendFile(this.currentFilePath, content, { mode: this.fileMode });
@@ -1453,7 +1555,7 @@ var FileTransport = class {
 	}
 	parseInterval(interval) {
 		const match = /^(\d{1,6})([hdwmy])$/i.exec(interval.trim());
-		if (!match) return 1440 * 60 * 1e3;
+		if (!match) return 864e5;
 		const value = Number.parseInt(match[1] || "1", 10);
 		switch ((match[2] || "h").toLowerCase()) {
 			case "h": return value * 60 * 60 * 1e3;
@@ -1568,9 +1670,7 @@ var FileTransport = class {
 		this.reportDropped(0);
 	}
 };
-
-//#endregion
-//#region src/transports/google-analytics.transport.ts
+// src/transports/google-analytics.transport.ts
 /**
 * Sends log entries as Google Analytics 4 Measurement Protocol events.
 *
@@ -1585,6 +1685,7 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 		this.baseUrl = "https://www.google-analytics.com/mp/collect";
 		this.debugUrl = "https://www.google-analytics.com/debug/mp/collect";
 		this.gaConfig = config;
+		protectSecrets(this, ["gaConfig"]);
 	}
 	async initialize() {
 		try {
@@ -1672,10 +1773,10 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 	}
 	async sendEvents(events) {
 		const chunks = this.chunkArray(events, 25);
-		for (const chunk$1 of chunks) {
+		for (const chunk of chunks) {
 			const payload = {
 				client_id: this.gaConfig.clientId || this.generateClientId(),
-				events: chunk$1
+				events: chunk
 			};
 			await this.makeRequest(payload);
 		}
@@ -1796,9 +1897,7 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 		await this.sendEvent(event);
 	}
 };
-
-//#endregion
-//#region src/transports/mixpanel.transport.ts
+// src/transports/mixpanel.transport.ts
 /**
 * Sends log entries as Mixpanel events via the Track and Engage HTTP APIs.
 *
@@ -1810,6 +1909,7 @@ var MixpanelTransport = class extends AnalyticsTransport {
 		super("mixpanel", config);
 		this.baseUrl = "https://api.mixpanel.com";
 		this.mixpanelConfig = config;
+		protectSecrets(this, ["mixpanelConfig"]);
 	}
 	async initialize() {
 		try {
@@ -1935,9 +2035,7 @@ var MixpanelTransport = class extends AnalyticsTransport {
 		await this.makeRequest("/track", [payload]);
 	}
 };
-
-//#endregion
-//#region src/version.ts
+// src/version.ts
 /**
 * The published version of this package.
 *
@@ -1946,9 +2044,7 @@ var MixpanelTransport = class extends AnalyticsTransport {
 * free of a JSON import that bundlers and consumers would have to resolve.
 */
 const LOGIXIA_VERSION = "1.12.0";
-
-//#endregion
-//#region src/transports/segment.transport.ts
+// src/transports/segment.transport.ts
 /**
 * Sends log entries as Segment track/identify events via the HTTP Tracking API.
 *
@@ -1966,6 +2062,10 @@ var SegmentTransport = class extends AnalyticsTransport {
 			...config
 		};
 		this.baseUrl = config.dataPlaneUrl || "https://api.segment.io";
+		protectSecrets(this, ["segmentConfig", "baseUrl"]);
+	}
+	secretValues() {
+		return [...super.secretValues(), Buffer.from(`${this.segmentConfig.writeKey}:`).toString("base64")];
 	}
 	async initialize() {
 		try {
@@ -2033,8 +2133,8 @@ var SegmentTransport = class extends AnalyticsTransport {
 	}
 	async batchTrack(events) {
 		const chunks = this.chunkArray(events, this.segmentConfig.maxBatchSize || 100);
-		for (const chunk$1 of chunks) {
-			const payload = { batch: chunk$1 };
+		for (const chunk of chunks) {
+			const payload = { batch: chunk };
 			await this.makeRequest("/v1/batch", payload);
 		}
 	}
@@ -2211,9 +2311,7 @@ var SegmentTransport = class extends AnalyticsTransport {
 		await this.makeRequest("/v1/track", payload);
 	}
 };
-
-//#endregion
-//#region src/transports/transport.manager.ts
+// src/transports/transport.manager.ts
 function _sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -2408,7 +2506,6 @@ var TransportManager = class extends EventEmitter {
 					case "linear":
 						wait = baseDelay * (attempt + 1);
 						break;
-					case "exponential":
 					default: wait = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
 				}
 				this.emit("transport:retry", transport.name, attempt + 1, maxRetries, wait);
@@ -2562,7 +2659,6 @@ var TransportManager = class extends EventEmitter {
 		internalLog("Transport level preferences cleared");
 	}
 };
+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 };
 
-//#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, stripControlChars as u };
-//# sourceMappingURL=transport.manager-CpdVHEGP.mjs.map
+//# sourceMappingURL=transport.manager-eZ_EeC00.mjs.map