logixia 2.0.10 → 2.1.0

package/dist/{otel-DOuwGPCd.mjs → otel-b-s2QbY4.mjs}

@@ -1,9 +1,10 @@
 import { t as __require } from "./rolldown-runtime-D3PmRqjj.mjs";
-import { n as protectSecrets, o as urlSecrets, r as scrubError, t as collectSecrets } from "./secret-config-ByGq7kJd.mjs";
+import { n as protectSecrets, o as urlSecrets, r as scrubError, t as collectSecrets } from "./secret-config-GKmb15Me.mjs";
 import { n as internalLog, r as internalWarn, t as internalError } from "./internal-log-Cy5nF1ZL.mjs";
-import { t as safeToString } from "./coerce.utils-B_rEudCn.mjs";
-import { i as stringifyForLog } from "./safe-stringify--7gbe95n.mjs";
-import { t as mergeCoreFields } from "./entry-fields-DNTKQxoU.mjs";
+import { i as stringifyForLog } from "./safe-stringify-B5p5ktFe.mjs";
+import { n as safeToString, t as csvField$1 } from "./csv.utils-ZdxSod5g.mjs";
+import { t as mergeCoreFields } from "./entry-fields-J1OBi24o.mjs";
+import { r as DEFAULT_REQUEST_TIMEOUT_MS } from "./batch-buffer-CM-lK_Qy.mjs";
 import { EventEmitter } from "node:events";
 import { promisify } from "node:util";
 import { createGzip, gzip } from "node:zlib";
@@ -36,12 +37,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(safeToString(value));
 	}
 	constructor(config = {}) {
 		this.config = config;
-		this.name = "console";
 		this.level = config.level;
 		if (config.filter) this.filter = config.filter;
 	}
@@ -105,26 +129,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;
@@ -137,10 +141,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;
@@ -244,7 +250,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;
@@ -271,11 +279,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;
 		protectSecrets(this, ["config", "connection"]);
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
@@ -294,9 +321,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);
@@ -321,6 +351,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);
@@ -418,6 +449,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));
+			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) 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) => {
@@ -454,6 +517,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) {
@@ -475,6 +539,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) {
@@ -495,6 +560,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 });
@@ -717,6 +783,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();
@@ -725,17 +792,19 @@ var DatabaseTransport = class {
 		}
 		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) {
+		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;
 	}
@@ -782,6 +851,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;
@@ -789,9 +859,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,
@@ -823,12 +914,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) => 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) => 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) => 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);
 		}
 	}
@@ -855,7 +947,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));
 				scrubError(error, this.secretValues());
 				internalError(`Analytics transport ${this.name} flush failed`, error);
 				this.batch.unshift(...error instanceof PartialBatchError ? error.unsent : entriesToSend);
@@ -918,6 +1014,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 = 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 = promisify(gzip);
 const MAX_LOGS_PER_REQUEST = 1e3;
@@ -995,6 +1113,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;
@@ -1153,7 +1275,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",
@@ -1170,7 +1292,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",
@@ -1215,7 +1337,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",
@@ -1240,7 +1362,7 @@ const DEFAULT_MAX_QUEUE = 1e4;
 const DEFAULT_FILE_MODE = 384;
 const DEFAULT_DIR_MODE = 448;
 function csvField(value) {
-	return `"${stripControlChars(safeToString(value)).replace(/"/g, "\"\"")}"`;
+	return csvField$1(stripControlChars(safeToString(value)), true);
 }
 const SIZE_UNITS = {
 	"": 1,
@@ -1285,21 +1407,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,
@@ -1387,6 +1539,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();
@@ -1398,6 +1551,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";
+			fs.appendFileSync(this.currentFilePath, content, { mode: this.fileMode });
+		} catch {}
+	}
 	queueFull() {
 		return this.batch.length + this.inFlight >= this.maxQueue;
 	}
@@ -1482,7 +1659,11 @@ var FileTransport = class {
 			case "json": return stringifyForLog(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(),
@@ -1504,9 +1685,12 @@ var FileTransport = class {
 				this.batchTimer = void 0;
 			}
 			this.startDrain();
-		} else if (!this.batchTimer && this.config.flushInterval) this.batchTimer = setTimeout(() => {
-			this.flush().catch((err) => internalError("FileTransport interval flush failed", err));
-		}, this.config.flushInterval);
+		} else if (!this.batchTimer && this.config.flushInterval) {
+			this.batchTimer = setTimeout(() => {
+				this.flush().catch((err) => 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) {
@@ -1672,6 +1856,7 @@ var FileTransport = class {
 			this.batchTimer = void 0;
 		}
 		await this.flush();
+		this.detachExitListener();
 		await this.housekeeping;
 		this.reportDropped(0);
 	}
@@ -1686,10 +1871,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;
 		protectSecrets(this, ["gaConfig"]);
 	}
@@ -1794,7 +1980,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: stringifyForLog(payload)
@@ -1941,9 +2127,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;
 		protectSecrets(this, ["mixpanelConfig"]);
 	}
@@ -2011,7 +2198,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",
@@ -2088,6 +2275,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 = {
@@ -2178,7 +2367,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",
@@ -2348,10 +2537,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 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
@@ -2359,11 +2555,6 @@ var TransportManager = class extends 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);
 	}
@@ -2436,8 +2627,9 @@ var TransportManager = class extends 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);
+			internalError(`Transport "${id}" failed to close`, error);
 		});
 		this.emit("transport:removed", id);
 		return true;
@@ -2453,7 +2645,10 @@ var TransportManager = class extends 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,
@@ -2491,6 +2686,27 @@ var TransportManager = class extends 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 = `${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);
@@ -2517,43 +2733,86 @@ var TransportManager = class extends 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) {
+			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 {
@@ -2561,8 +2820,65 @@ var TransportManager = class extends 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) {
+			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) {
+			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());
@@ -2581,19 +2897,35 @@ var TransportManager = class extends 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) => {
@@ -2810,4 +3142,4 @@ function disableOtelBridge() {
 }
 export { ConsoleTransport as _, getActiveOtelContext as a, TransportManager as c, GoogleAnalyticsTransport as d, FileTransport as f, BufferCap as g, DatabaseTransport as h, disableOtelBridge as i, SegmentTransport as l, AnalyticsTransport as m, _getOtelPayloadIfEnabled as n, getOtelMetaFields as o, DataDogTransport as p, _isOtelBridgeEnabled as r, initOtelBridge as s, _getOtelBridgeFieldNames as t, MixpanelTransport as u, stripControlChars as v };
 
-//# sourceMappingURL=otel-DOuwGPCd.mjs.map
+//# sourceMappingURL=otel-b-s2QbY4.mjs.map