logixia 2.0.10 → 2.1.0

package/dist/{otel-ChnVYRLA.js → otel-8ypFGG19.js}

@@ -1,8 +1,9 @@
-const require_secret_config = require("./secret-config-BvFl2dC8.js");
+const require_secret_config = require("./secret-config--cVTOWwp.js");
 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_entry_fields = require("./entry-fields-CVwoQplO.js");
+const require_safe_stringify = require("./safe-stringify-J3sh-7YM.js");
+const require_csv_utils = require("./csv.utils-CbVHY1pd.js");
+const require_entry_fields = require("./entry-fields-BSLkzw18.js");
+const require_batch_buffer = require("./batch-buffer-BLmVvJAZ.js");
 let node_events = require("node:events");
 let node_util = require("node:util");
 let node_zlib = require("node:zlib");
@@ -37,12 +38,35 @@ function stripControlChars(value) {
 * transports: { console: { format: 'json' } }
 */
 var ConsoleTransport = class ConsoleTransport {
+	config;
+	name = "console";
+	level;
+	filter;
+	static 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"]
+	]);
 	static sanitize(value) {
-		return stripControlChars(require_coerce_utils.safeToString(value));
+		return stripControlChars(require_csv_utils.safeToString(value));
 	}
 	constructor(config = {}) {
 		this.config = config;
-		this.name = "console";
 		this.level = config.level;
 		if (config.filter) this.filter = config.filter;
 	}
@@ -106,26 +130,6 @@ 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"]
-	]);
 };
 // src/transports/buffer-cap.ts
 const DEFAULT_BUFFER_CAP = 1e4;
@@ -138,10 +142,12 @@ const DROP_WARN_INTERVAL_MS$1 = 5e3;
 * A cap below `batchSize` is raised to `batchSize` so one batch always fits.
 */
 var BufferCap = class {
+	name;
+	max;
+	dropped = 0;
+	lastWarning = 0;
 	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;
@@ -245,7 +251,9 @@ function isDataError(type, error) {
 	return false;
 }
 /** A write that stored part of a batch: only `remaining` still needs to be written. */
+var DatabaseUnavailableError = class extends Error {};
 var PartialWriteError = class extends Error {
+	remaining;
 	constructor(message, remaining, cause) {
 		super(message, { cause });
 		this.remaining = remaining;
@@ -272,11 +280,30 @@ function validateSqlIdentifier(name, label = "table") {
 * }
 */
 var DatabaseTransport = class {
+	config;
+	name = "database";
+	batchSize;
+	flushInterval;
+	level;
+	filter;
+	batch = [];
+	flushTimer;
+	/**
+	* The in-flight drain promise, or undefined when idle. Concurrent flush()
+	* calls (the un-awaited threshold flush write() fires, plus the interval
+	* timer) all await this single promise instead of starting their own drain,
+	* so a batch is never snapshotted and written twice. Mirrors the FileTransport
+	* fix for the overlapping-batch-flush duplication bug.
+	*/
+	flushPromise;
+	connection;
+	isConnected = false;
+	connectionPromise;
+	connectFailures = 0;
+	nextConnectAt = 0;
+	cap;
 	constructor(config) {
 		this.config = config;
-		this.name = "database";
-		this.batch = [];
-		this.isConnected = false;
 		require_secret_config.protectSecrets(this, ["config", "connection"]);
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
@@ -295,9 +322,12 @@ var DatabaseTransport = class {
 		];
 	}
 	async write(entry) {
-		if (!this.isConnected) await this.connect();
 		this.addToBatch(entry);
-		if (this.batch.length >= this.batchSize) await this.flush();
+		if (this.batch.length >= this.batchSize) try {
+			await this.flush();
+		} catch (error) {
+			if (!(error instanceof DatabaseUnavailableError)) throw error;
+		}
 	}
 	addToBatch(entry) {
 		this.batch.push(entry);
@@ -322,6 +352,7 @@ var DatabaseTransport = class {
 	*/
 	async drain() {
 		while (this.batch.length > 0) {
+			await this.ensureConnected();
 			const entries = this.batch.splice(0, this.batchSize);
 			try {
 				await this.writeEntries(entries);
@@ -419,6 +450,38 @@ var DatabaseTransport = class {
 			return false;
 		}
 	}
+	async ensureConnected() {
+		if (this.isConnected) return;
+		const wait = this.nextConnectAt - Date.now();
+		if (wait > 0) throw new DatabaseUnavailableError(`Database unavailable; next connect attempt in ${wait}ms`);
+		try {
+			await this.connect();
+			this.connectFailures = 0;
+		} catch (error) {
+			this.connectFailures += 1;
+			this.nextConnectAt = Date.now() + Math.min(3e4, 1e3 * 2 ** (this.connectFailures - 1));
+			require_internal_log.internalError("Database connection error", error);
+			throw new DatabaseUnavailableError("Database unavailable", { cause: error });
+		}
+	}
+	/**
+	* The driver reported the connection gone (idle timeout, server restart,
+	* network drop). Forget it so the next flush reconnects; without an 'error'
+	* listener the driver's emitter would crash the process.
+	*/
+	onConnectionLost(connection, error) {
+		if (this.connection !== connection) return;
+		if (error) require_internal_log.internalError("Database connection lost", error);
+		this.isConnected = false;
+		this.connectionPromise = void 0;
+		this.connection = void 0;
+	}
+	watchConnection(connection) {
+		var _connection$on, _connection$on2;
+		const lost = (error) => this.onConnectionLost(connection, error);
+		(_connection$on = connection.on) === null || _connection$on === void 0 || _connection$on.call(connection, "error", lost);
+		(_connection$on2 = connection.on) === null || _connection$on2 === void 0 || _connection$on2.call(connection, "end", () => lost());
+	}
 	async connect() {
 		if (this.connectionPromise) return this.connectionPromise;
 		this.connectionPromise = this.establishConnection().catch((error) => {
@@ -455,6 +518,7 @@ var DatabaseTransport = class {
 			});
 			const connectionString = this.config.connectionString || `mongodb://${this.config.host}:${this.config.port}/${this.config.database}`;
 			this.connection = new MongoClient(connectionString);
+			this.watchConnection(this.connection);
 			await this.connection.connect();
 			await this.connection.db(this.config.database).admin().ping();
 		} catch (error) {
@@ -476,6 +540,7 @@ var DatabaseTransport = class {
 			if (this.config.password) config.password = this.config.password;
 			if (this.config.ssl) config.ssl = typeof this.config.ssl === "boolean" ? {} : this.config.ssl;
 			this.connection = new Client(config);
+			this.watchConnection(this.connection);
 			await this.connection.connect();
 			await this.createPostgreSQLTable();
 		} catch (error) {
@@ -496,6 +561,7 @@ var DatabaseTransport = class {
 			if (this.config.password) config.password = this.config.password;
 			if (this.config.ssl) config.ssl = typeof this.config.ssl === "boolean" ? {} : this.config.ssl;
 			this.connection = await mysql.createConnection(config);
+			this.watchConnection(this.connection);
 			await this.createMySQLTable();
 		} catch (error) {
 			throw new Error(`MySQL connection failed: ${error}`, { cause: error });
@@ -718,6 +784,7 @@ var DatabaseTransport = class {
 			this.flushTimer = void 0;
 		}
 		const MAX_CLOSE_FLUSH_ATTEMPTS = 3;
+		this.nextConnectAt = 0;
 		if (this.flushPromise) await this.flushPromise.catch(() => {});
 		for (let attempt = 0; attempt < MAX_CLOSE_FLUSH_ATTEMPTS && this.batch.length > 0; attempt += 1) try {
 			await this.flush();
@@ -726,17 +793,19 @@ var DatabaseTransport = class {
 		}
 		if (this.batch.length > 0) require_internal_log.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) {
+		const connection = this.connection;
+		this.connection = void 0;
+		if (connection) switch (this.config.type) {
 			case "mongodb":
-				await this.connection.close();
+				await connection.close();
 				break;
 			case "postgresql":
-				await this.connection.end();
+				await connection.end();
 				break;
 			case "mysql":
-				await this.connection.end();
+				await connection.end();
 				break;
-			case "sqlite": await this.connection.close();
+			case "sqlite": await connection.close();
 		}
 		this.isConnected = false;
 	}
@@ -783,6 +852,7 @@ var DatabaseTransport = class {
 * requeues only `unsent`, so delivered entries are not sent twice.
 */
 var PartialBatchError = class extends Error {
+	unsent;
 	constructor(message, unsent, options) {
 		super(message, options);
 		this.unsent = unsent;
@@ -790,9 +860,30 @@ var PartialBatchError = class extends Error {
 	}
 };
 var AnalyticsTransport = class {
+	name;
+	level;
+	batchSize;
+	flushInterval;
+	config;
+	batch = [];
+	batchTimer;
+	isReady = false;
+	/**
+	* The in-flight drain promise, or undefined when idle. addToBatch() fires
+	* flush() un-awaited on every Nth entry, so a synchronous burst can trigger
+	* many overlapping flushes. Every caller joins this single promise instead of
+	* starting its own drain, so a batch is never snapshotted and sent twice —
+	* the overlapping-flush duplication that turns N logs into N² delivered events
+	* (same class of bug fixed earlier in FileTransport / DatabaseTransport).
+	*/
+	flushPromise;
+	/** Set on the first write. Subclass fields don't exist yet while the base constructor runs. */
+	initPromise;
+	cap;
+	/** Consecutive failed drains; drives the backoff that stops a failing provider being re-sent every Nth log. */
+	failures = 0;
+	retryAt = 0;
 	constructor(name, config) {
-		this.batch = [];
-		this.isReady = false;
 		this.name = name;
 		this.config = {
 			batchSize: 50,
@@ -824,12 +915,13 @@ 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) => require_internal_log.internalError(`${this.name} batch flush failed`, err));
-		else if (!this.batchTimer && this.config.flushInterval) {
+		const backoff = this.retryAt - Date.now();
+		if (this.batch.length >= (this.config.batchSize || 50) && backoff <= 0) this.flush().catch((err) => require_internal_log.internalError(`${this.name} batch flush failed`, err));
+		else if (!this.batchTimer && (this.config.flushInterval || backoff > 0)) {
 			var _this$batchTimer$unre, _this$batchTimer;
 			this.batchTimer = setTimeout(() => {
 				this.flush().catch((err) => require_internal_log.internalError(`${this.name} interval flush failed`, err));
-			}, this.config.flushInterval);
+			}, Math.max(this.config.flushInterval || 0, backoff));
 			(_this$batchTimer$unre = (_this$batchTimer = this.batchTimer).unref) === null || _this$batchTimer$unre === void 0 || _this$batchTimer$unre.call(_this$batchTimer);
 		}
 	}
@@ -856,7 +948,11 @@ var AnalyticsTransport = class {
 			this.batch = [];
 			try {
 				await this.sendBatch(entriesToSend);
+				this.failures = 0;
+				this.retryAt = 0;
 			} catch (error) {
+				this.failures += 1;
+				this.retryAt = Date.now() + Math.min(6e4, 1e3 * 2 ** (this.failures - 1));
 				require_secret_config.scrubError(error, this.secretValues());
 				require_internal_log.internalError(`Analytics transport ${this.name} flush failed`, error);
 				this.batch.unshift(...error instanceof PartialBatchError ? error.unsent : entriesToSend);
@@ -919,6 +1015,28 @@ var AnalyticsTransport = class {
 		await this.ensureReady();
 	}
 };
+// src/transports/fetch-timeout.ts
+/**
+* fetch() with a hard deadline, so an endpoint that accepts the connection and
+* never answers cannot hang a flush (and with it close()) forever. Uses an
+* AbortController rather than AbortSignal.timeout(), which needs Node 17.3+
+* while `engines` allows 16; the timer is unref'd so it never holds the process.
+*/
+async function fetchWithTimeout(url, init, timeoutMs = require_batch_buffer.DEFAULT_REQUEST_TIMEOUT_MS) {
+	var _timer$unref;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	(_timer$unref = timer.unref) === null || _timer$unref === void 0 || _timer$unref.call(timer);
+	try {
+		return await fetch(url, {
+			...init,
+			signal: controller.signal
+		});
+	} catch (error) {
+		if (controller.signal.aborted) throw new Error(`Request timed out after ${timeoutMs}ms`, { cause: error });
+		throw error;
+	}
+}
 // src/transports/datadog.transport.ts
 const gzipAsync = (0, node_util.promisify)(node_zlib.gzip);
 const MAX_LOGS_PER_REQUEST = 1e3;
@@ -996,6 +1114,10 @@ function tag(key, value) {
 * analytics: { datadog: { apiKey: process.env.DD_API_KEY, service: 'api', env: 'production' } }
 */
 var DataDogTransport = class extends AnalyticsTransport {
+	datadogConfig;
+	baseUrl;
+	logsUrl;
+	metricsUrl;
 	constructor(config) {
 		super("datadog", config);
 		this.datadogConfig = config;
@@ -1154,7 +1276,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 		const url = `${this.logsUrl}${endpoint}`;
 		try {
 			const compress = this.datadogConfig.compress === true;
-			const response = await fetch(url, {
+			const response = await fetchWithTimeout(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -1171,7 +1293,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 	async makeMetricsRequest(endpoint, data) {
 		const url = `${this.metricsUrl}${endpoint}`;
 		try {
-			const response = await fetch(url, {
+			const response = await fetchWithTimeout(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -1216,7 +1338,7 @@ var DataDogTransport = class extends AnalyticsTransport {
 		};
 		const url = `${this.baseUrl}/api/v1/events`;
 		try {
-			const response = await fetch(url, {
+			const response = await fetchWithTimeout(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -1241,7 +1363,7 @@ const DEFAULT_MAX_QUEUE = 1e4;
 const DEFAULT_FILE_MODE = 384;
 const DEFAULT_DIR_MODE = 448;
 function csvField(value) {
-	return `"${stripControlChars(require_coerce_utils.safeToString(value)).replace(/"/g, "\"\"")}"`;
+	return require_csv_utils.csvField(stripControlChars(require_csv_utils.safeToString(value)), true);
 }
 const SIZE_UNITS = {
 	"": 1,
@@ -1286,21 +1408,51 @@ function formatDatePattern(date, pattern) {
 * transports: { file: { filename: 'app.log', dirname: './logs', maxSize: '50MB' } }
 */
 var FileTransport = class {
+	name = "file";
+	level;
+	batchSize;
+	flushInterval;
+	filter;
+	config;
+	maxBytes;
+	maxFiles;
+	compress;
+	intervalMs;
+	timestampedActive;
+	dir;
+	base;
+	ext;
+	batch = [];
+	batchTimer;
+	lastRotation = /* @__PURE__ */ new Date();
+	currentFilePath;
+	bytesWritten = 0;
+	period;
+	rotateRequested = false;
+	rotationWaiters = [];
+	/**
+	* The one drain loop, or undefined when idle. Only one ever runs, so the batch
+	* is never snapshotted and written twice, and rotation (which runs inside it)
+	* never races a write.
+	*/
+	draining;
+	/** Entries queued and entries written (or failed) so far; flush() waits on these. */
+	enqueued = 0;
+	settled = 0;
+	flushWaiters = [];
+	maxQueue;
+	fileMode;
+	dirMode;
+	queuePolicy;
+	spaceWaiters = [];
+	inFlight = 0;
+	dropped = 0;
+	lastDropWarning = 0;
+	/** Gzip and pruning of rotated files run off the write path, one at a time. */
+	housekeeping = Promise.resolve();
+	exitListenerAttached = false;
+	onExit = () => this.flushSyncOnExit();
 	constructor(config) {
-		this.name = "file";
-		this.batch = [];
-		this.lastRotation = /* @__PURE__ */ new Date();
-		this.bytesWritten = 0;
-		this.rotateRequested = false;
-		this.rotationWaiters = [];
-		this.enqueued = 0;
-		this.settled = 0;
-		this.flushWaiters = [];
-		this.spaceWaiters = [];
-		this.inFlight = 0;
-		this.dropped = 0;
-		this.lastDropWarning = 0;
-		this.housekeeping = Promise.resolve();
 		this.config = {
 			format: "json",
 			batchSize: 100,
@@ -1388,6 +1540,7 @@ var FileTransport = class {
 		await done;
 	}
 	enqueue(entry) {
+		this.attachExitListener();
 		if (this.queueFull()) {
 			if (this.queuePolicy === "drop-oldest" && this.batch.length > 0) {
 				this.batch.shift();
@@ -1399,6 +1552,30 @@ var FileTransport = class {
 		this.batch.push(entry);
 		this.enqueued += 1;
 	}
+	attachExitListener() {
+		if (this.exitListenerAttached) return;
+		this.exitListenerAttached = true;
+		process.on("exit", this.onExit);
+	}
+	detachExitListener() {
+		if (!this.exitListenerAttached) return;
+		this.exitListenerAttached = false;
+		process.removeListener("exit", this.onExit);
+	}
+	/**
+	* Last chance on process exit: async writes cannot finish, so whatever is still
+	* batched is appended synchronously to the current file.
+	*/
+	flushSyncOnExit() {
+		if (this.batch.length === 0) return;
+		const pending = this.batch;
+		this.batch = [];
+		this.enqueued -= pending.length;
+		try {
+			const content = pending.map((entry) => this.formatEntry(entry)).join("\n") + "\n";
+			node_fs.appendFileSync(this.currentFilePath, content, { mode: this.fileMode });
+		} catch {}
+	}
 	queueFull() {
 		return this.batch.length + this.inFlight >= this.maxQueue;
 	}
@@ -1483,7 +1660,11 @@ var FileTransport = class {
 			case "json": return require_safe_stringify.stringifyForLog(require_entry_fields.mergeCoreFields({
 				timestamp: entry.timestamp.toISOString(),
 				level: entry.level,
-				message: entry.message
+				message: entry.message,
+				context: entry.context,
+				traceId: entry.traceId,
+				appName: entry.appName,
+				environment: entry.environment
 			}, entry.data));
 			case "csv": return [
 				entry.timestamp.toISOString(),
@@ -1493,7 +1674,7 @@ var FileTransport = class {
 				csvField(entry.traceId),
 				csvField(require_safe_stringify.stringifyForLog(entry.data || {}))
 			].join(",");
-			default: return `${entry.timestamp.toISOString()} [${stripControlChars(require_coerce_utils.safeToString(entry.level)).toUpperCase()}] ${stripControlChars(require_coerce_utils.safeToString(entry.message))}${entry.data ? " " + require_safe_stringify.stringifyForLog(entry.data) : ""}`;
+			default: return `${entry.timestamp.toISOString()} [${stripControlChars(require_csv_utils.safeToString(entry.level)).toUpperCase()}] ${stripControlChars(require_csv_utils.safeToString(entry.message))}${entry.data ? " " + require_safe_stringify.stringifyForLog(entry.data) : ""}`;
 		}
 	}
 	addToBatch(entry) {
@@ -1505,9 +1686,12 @@ var FileTransport = class {
 				this.batchTimer = void 0;
 			}
 			this.startDrain();
-		} else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
-			this.flush().catch((err) => require_internal_log.internalError("FileTransport interval flush failed", err));
-		}, this.config.flushInterval);
+		} else if (!this.batchTimer && this.config.flushInterval) {
+			this.batchTimer = setTimeout(() => {
+				this.flush().catch((err) => require_internal_log.internalError("FileTransport interval flush failed", err));
+			}, this.config.flushInterval);
+			this.batchTimer.unref();
+		}
 	}
 	/** Only ever called from drain(), so writes and rotations never overlap. */
 	async writeBatch(entries) {
@@ -1673,6 +1857,7 @@ var FileTransport = class {
 			this.batchTimer = void 0;
 		}
 		await this.flush();
+		this.detachExitListener();
 		await this.housekeeping;
 		this.reportDropped(0);
 	}
@@ -1687,10 +1872,11 @@ var FileTransport = class {
 * }
 */
 var GoogleAnalyticsTransport = class extends AnalyticsTransport {
+	gaConfig;
+	baseUrl = "https://www.google-analytics.com/mp/collect";
+	debugUrl = "https://www.google-analytics.com/debug/mp/collect";
 	constructor(config) {
 		super("google-analytics", config);
-		this.baseUrl = "https://www.google-analytics.com/mp/collect";
-		this.debugUrl = "https://www.google-analytics.com/debug/mp/collect";
 		this.gaConfig = config;
 		require_secret_config.protectSecrets(this, ["gaConfig"]);
 	}
@@ -1795,7 +1981,7 @@ var GoogleAnalyticsTransport = class extends AnalyticsTransport {
 			api_secret: this.gaConfig.apiSecret
 		});
 		try {
-			const response = await fetch(`${url}?${params}`, {
+			const response = await fetchWithTimeout(`${url}?${params}`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: require_safe_stringify.stringifyForLog(payload)
@@ -1942,9 +2128,10 @@ function meetsTransportLevel(threshold, level, values) {
 * analytics: { mixpanel: { token: process.env.MIXPANEL_TOKEN } }
 */
 var MixpanelTransport = class extends AnalyticsTransport {
+	mixpanelConfig;
+	baseUrl = "https://api.mixpanel.com";
 	constructor(config) {
 		super("mixpanel", config);
-		this.baseUrl = "https://api.mixpanel.com";
 		this.mixpanelConfig = config;
 		require_secret_config.protectSecrets(this, ["mixpanelConfig"]);
 	}
@@ -2012,7 +2199,7 @@ var MixpanelTransport = class extends AnalyticsTransport {
 	async makeRequest(endpoint, data) {
 		const url = `${this.mixpanelConfig.endpoint || this.baseUrl}${endpoint}`;
 		try {
-			const response = await fetch(url, {
+			const response = await fetchWithTimeout(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -2089,6 +2276,8 @@ const LOGIXIA_VERSION = "1.12.0";
 * analytics: { segment: { writeKey: process.env.SEGMENT_WRITE_KEY } }
 */
 var SegmentTransport = class extends AnalyticsTransport {
+	segmentConfig;
+	baseUrl;
 	constructor(config) {
 		super("segment", config);
 		this.segmentConfig = {
@@ -2179,7 +2368,7 @@ var SegmentTransport = class extends AnalyticsTransport {
 		const url = `${this.baseUrl}${endpoint}`;
 		const auth = Buffer.from(`${this.segmentConfig.writeKey}:`).toString("base64");
 		try {
-			const response = await fetch(url, {
+			const response = await fetchWithTimeout(url, {
 				method: "POST",
 				headers: {
 					"Content-Type": "application/json",
@@ -2349,10 +2538,17 @@ var SegmentTransport = class extends AnalyticsTransport {
 	}
 };
 // src/transports/transport.manager.ts
-function _sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
+const DEFAULT_MAX_PENDING_RETRIES = 1e3;
+const RETRY_WARN_INTERVAL_MS = 5e3;
 var TransportManager = class extends node_events.EventEmitter {
+	transports = /* @__PURE__ */ new Map();
+	metrics = /* @__PURE__ */ new Map();
+	isShuttingDown = false;
+	transportLevelPreferences = /* @__PURE__ */ new Map();
+	warnedPromptDeprecated = false;
+	closePromise;
+	retryStates = /* @__PURE__ */ new Map();
+	levelValues;
 	/**
 	* @param config  Transport configuration.
 	* @param levels  The logger's `levelOptions.levels`; used with the built-in levels
@@ -2360,11 +2556,6 @@ var TransportManager = class extends node_events.EventEmitter {
 	*/
 	constructor(config = {}, levels) {
 		super();
-		this.transports = /* @__PURE__ */ new Map();
-		this.metrics = /* @__PURE__ */ new Map();
-		this.isShuttingDown = false;
-		this.transportLevelPreferences = /* @__PURE__ */ new Map();
-		this.warnedPromptDeprecated = false;
 		this.levelValues = buildLevelValues(levels);
 		this.setupTransports(config);
 	}
@@ -2437,8 +2628,9 @@ var TransportManager = class extends node_events.EventEmitter {
 		if (!transport) return false;
 		this.transports.delete(id);
 		this.metrics.delete(id);
+		this.drainRetries(id, transport);
 		if (transport.close) transport.close().catch((error) => {
-			this.emit("error", error, id);
+			require_internal_log.internalError(`Transport "${id}" failed to close`, error);
 		});
 		this.emit("transport:removed", id);
 		return true;
@@ -2454,7 +2646,10 @@ var TransportManager = class extends node_events.EventEmitter {
 	* sync path.
 	*/
 	write(entry) {
-		if (this.isShuttingDown) return;
+		if (this.isShuttingDown) {
+			this.writeAfterClose(entry);
+			return;
+		}
 		const transportEntry = {
 			timestamp: typeof entry.timestamp === "string" ? new Date(entry.timestamp) : entry.timestamp,
 			level: entry.level,
@@ -2492,6 +2687,27 @@ var TransportManager = class extends node_events.EventEmitter {
 			}
 		});
 	}
+	/**
+	* Transports are gone once closed, but the app may still log (its own signal
+	* handler, a late async callback). Emit such lines on stdout/stderr rather
+	* than losing them silently.
+	*/
+	writeAfterClose(entry) {
+		const line = `${require_safe_stringify.stringifyForLog({
+			timestamp: entry.timestamp,
+			level: entry.level,
+			message: entry.message,
+			appName: entry.appName,
+			context: entry.context,
+			traceId: entry.traceId,
+			...entry.payload
+		})}\n`;
+		const level = String(entry.level).toLowerCase();
+		const stream = level === "error" || level === "warn" ? "stderr" : "stdout";
+		try {
+			process[stream].write(line);
+		} catch {}
+	}
 	writeToTransport(id, transport, entry) {
 		const startTime = Date.now();
 		const metrics = this.metrics.get(id);
@@ -2518,43 +2734,86 @@ var TransportManager = class extends node_events.EventEmitter {
 			onSuccess();
 			return;
 		}
-		return this._writeWithRetry(transport, entry).then(onSuccess, onError);
+		return this._writeWithRetry(id, transport, entry).then((written) => {
+			if (written) onSuccess();
+		}, onError);
 	}
 	/**
 	* Feature 9: Multi-transport retry + failover.
 	*
-	* Attempts `transport.write()` up to `retry.maxRetries + 1` times with the
-	* configured backoff strategy. If all attempts fail and a fallback transport
-	* is configured, routes the entry there instead.
+	* The first attempt is awaited by the caller. If it fails, the entry moves to
+	* a bounded per-transport retry queue and the caller's promise resolves, so a
+	* down transport never holds a log call across backoff. The queue retries up
+	* to `retry.maxRetries` more times with the configured backoff, then routes
+	* the entry to the fallback transport (if any) and calls `onExhausted`.
+	* Returns true when the first attempt succeeded.
 	*/
-	async _writeWithRetry(transport, entry) {
-		const retryCfg = transport.retry;
-		if (!retryCfg || !retryCfg.maxRetries) {
+	async _writeWithRetry(id, transport, entry) {
+		try {
 			await transport.write(entry);
-			return;
+			return true;
+		} catch (err) {
+			this.enqueueRetry(id, transport, entry, err instanceof Error ? err : new Error(String(err)));
+			return false;
 		}
-		const { maxRetries, backoff = "exponential", delay: baseDelay = 500, maxDelay = 3e4, fallback, onExhausted } = retryCfg;
-		let lastError = /* @__PURE__ */ new Error("Unknown transport error");
-		for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-			await transport.write(entry);
+	}
+	enqueueRetry(id, transport, entry, error) {
+		let state = this.retryStates.get(id);
+		if (!state) {
+			state = {
+				queue: [],
+				timer: void 0,
+				running: false,
+				dropped: 0,
+				lastWarn: 0
+			};
+			this.retryStates.set(id, state);
+		}
+		const maxPending = transport.retry.maxPending ?? DEFAULT_MAX_PENDING_RETRIES;
+		while (state.queue.length >= maxPending) {
+			state.queue.shift();
+			state.dropped++;
+		}
+		this.warnDropped(id, state);
+		this.scheduleRetry(id, transport, state, {
+			entry,
+			attempt: 0,
+			due: 0
+		}, error);
+		this.pumpRetries(id, transport, state);
+	}
+	warnDropped(id, state) {
+		const now = Date.now();
+		if (state.dropped > 0 && now - state.lastWarn >= RETRY_WARN_INTERVAL_MS) {
+			require_internal_log.internalWarn(`TransportManager: retry queue for "${id}" is full; dropped ${state.dropped} oldest log entr${state.dropped === 1 ? "y" : "ies"}`);
+			state.dropped = 0;
+			state.lastWarn = now;
+		}
+	}
+	/** Queues `item` for its next attempt, or finishes it when retries ran out. */
+	scheduleRetry(id, transport, state, item, error) {
+		const { maxRetries = 0, backoff = "exponential", delay = 500, maxDelay = 3e4 } = transport.retry;
+		if (item.attempt >= maxRetries) {
+			this.exhaust(id, transport, item.entry, error);
 			return;
-		} catch (err) {
-			lastError = err instanceof Error ? err : new Error(String(err));
-			if (attempt < maxRetries) {
-				let wait;
-				switch (backoff) {
-					case "fixed":
-						wait = baseDelay;
-						break;
-					case "linear":
-						wait = baseDelay * (attempt + 1);
-						break;
-					default: wait = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
-				}
-				this.emit("transport:retry", transport.name, attempt + 1, maxRetries, wait);
-				await _sleep(wait);
-			}
 		}
+		let wait;
+		switch (backoff) {
+			case "fixed":
+				wait = delay;
+				break;
+			case "linear":
+				wait = delay * (item.attempt + 1);
+				break;
+			default: wait = Math.min(delay * Math.pow(2, item.attempt), maxDelay);
+		}
+		item.attempt++;
+		item.due = Date.now() + wait;
+		state.queue.push(item);
+		this.emit("transport:retry", transport.name, item.attempt, maxRetries, wait);
+	}
+	async exhaust(id, transport, entry, error) {
+		const { fallback, onExhausted } = transport.retry;
 		if (fallback) {
 			this.emit("transport:fallback", transport.name, fallback.name);
 			try {
@@ -2562,8 +2821,65 @@ var TransportManager = class extends node_events.EventEmitter {
 				return;
 			} catch {}
 		}
-		onExhausted === null || onExhausted === void 0 || onExhausted(lastError, entry);
-		throw lastError;
+		const metrics = this.metrics.get(id);
+		if (metrics) metrics.errors++;
+		try {
+			onExhausted === null || onExhausted === void 0 || onExhausted(error, entry);
+		} catch (hookError) {
+			require_internal_log.internalWarn(`TransportManager: onExhausted for "${id}" threw: ${String(hookError)}`);
+		}
+		if (this.listenerCount("error") > 0) this.emit("error", error, id);
+	}
+	/** One serial worker per transport: the earliest-due entry is retried first. */
+	pumpRetries(id, transport, state) {
+		var _state$timer$unref, _state$timer;
+		if (state.running || state.timer || state.queue.length === 0) return;
+		let next = 0;
+		for (let i = 1; i < state.queue.length; i++) if (state.queue[i].due < state.queue[next].due) next = i;
+		const wait = Math.max(0, state.queue[next].due - Date.now());
+		state.timer = setTimeout(() => {
+			state.timer = void 0;
+			this.runRetry(id, transport, state);
+		}, wait);
+		(_state$timer$unref = (_state$timer = state.timer).unref) === null || _state$timer$unref === void 0 || _state$timer$unref.call(_state$timer);
+	}
+	async runRetry(id, transport, state) {
+		if (state.queue.length === 0) return;
+		let next = 0;
+		for (let i = 1; i < state.queue.length; i++) if (state.queue[i].due < state.queue[next].due) next = i;
+		const [item] = state.queue.splice(next, 1);
+		if (!item) return;
+		state.running = true;
+		try {
+			await transport.write(item.entry);
+			const metrics = this.metrics.get(id);
+			if (metrics) {
+				metrics.logsWritten++;
+				metrics.lastWrite = /* @__PURE__ */ new Date();
+			}
+			this.emit("log", item.entry);
+		} catch (err) {
+			this.scheduleRetry(id, transport, state, item, err instanceof Error ? err : new Error(String(err)));
+		} finally {
+			state.running = false;
+		}
+		if (!this.isShuttingDown) this.pumpRetries(id, transport, state);
+	}
+	/** Stops a transport's retry worker and hands what is still queued to its fallback. */
+	async drainRetries(id, transport) {
+		var _transport$retry;
+		const state = this.retryStates.get(id);
+		if (!state) return;
+		this.retryStates.delete(id);
+		if (state.timer) clearTimeout(state.timer);
+		state.timer = void 0;
+		const fallback = transport === null || transport === void 0 || (_transport$retry = transport.retry) === null || _transport$retry === void 0 ? void 0 : _transport$retry.fallback;
+		if (state.queue.length === 0) return;
+		if (!fallback) {
+			require_internal_log.internalWarn(`TransportManager: "${id}" closed with ${state.queue.length} log entr${state.queue.length === 1 ? "y" : "ies"} still awaiting retry`);
+			return;
+		}
+		await Promise.allSettled(state.queue.map((item) => fallback.write(item.entry)));
 	}
 	shouldTransportHandle(transport, level, transportId) {
 		if (transportId && this.transportLevelPreferences.has(transportId)) return this.transportLevelPreferences.get(transportId).includes(level.toLowerCase());
@@ -2582,19 +2898,35 @@ var TransportManager = class extends node_events.EventEmitter {
 		if (readyPromises.length > 0) await Promise.all(readyPromises);
 	}
 	async flush() {
+		await this.flushTransports(false);
+	}
+	/**
+	* @param skipClosable  Leave out transports with a close(): close() flushes
+	*   them itself, and a second flush first would double the time a hung
+	*   endpoint can hold shutdown.
+	*/
+	async flushTransports(skipClosable) {
 		const flushPromises = [];
-		for (const [id, transport] of this.transports) if (this.isBatchTransport(transport)) {
-			const flushPromise = transport.flush().catch((error) => {
-				this.emit("error", error, id);
-			});
-			flushPromises.push(flushPromise);
+		for (const [id, transport] of this.transports) {
+			if (skipClosable && transport.close) continue;
+			if (this.isBatchTransport(transport)) {
+				const flushPromise = transport.flush().catch((error) => {
+					this.emit("error", error, id);
+				});
+				flushPromises.push(flushPromise);
+			}
 		}
 		await Promise.allSettled(flushPromises);
 		this.emit("flush", "all", this.transports.size);
 	}
-	async close() {
-		await this.flush();
+	close() {
+		this.closePromise ??= this.closeOnce();
+		return this.closePromise;
+	}
+	async closeOnce() {
+		await this.flushTransports(true);
 		this.isShuttingDown = true;
+		await Promise.allSettled([...this.retryStates.keys()].map((id) => this.drainRetries(id, this.transports.get(id))));
 		const closePromises = [];
 		for (const [id, transport] of this.transports) if (transport.close) {
 			const closePromise = transport.close().catch((error) => {
@@ -2918,4 +3250,4 @@ Object.defineProperty(exports, "stripControlChars", {
 	}
 });
 
-//# sourceMappingURL=otel-ChnVYRLA.js.map
+//# sourceMappingURL=otel-8ypFGG19.js.map