logixia 2.0.11 → 2.1.0

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

@@ -1,8 +1,9 @@
-const require_secret_config = require("./secret-config-6hdODxBb.js");
+const require_secret_config = require("./secret-config--cVTOWwp.js");
 const require_internal_log = require("./internal-log-DwqTjhpb.js");
+const require_safe_stringify = require("./safe-stringify-J3sh-7YM.js");
 const require_csv_utils = require("./csv.utils-CbVHY1pd.js");
-const require_safe_stringify = require("./safe-stringify-CJisLyZ3.js");
-const require_entry_fields = require("./entry-fields-CJbeaoBs.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");
@@ -250,6 +251,7 @@ 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) {
@@ -297,6 +299,8 @@ var DatabaseTransport = class {
 	connection;
 	isConnected = false;
 	connectionPromise;
+	connectFailures = 0;
+	nextConnectAt = 0;
 	cap;
 	constructor(config) {
 		this.config = config;
@@ -318,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);
@@ -345,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);
@@ -442,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) => {
@@ -478,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) {
@@ -499,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) {
@@ -519,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 });
@@ -741,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();
@@ -749,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;
 	}
@@ -834,6 +880,9 @@ var AnalyticsTransport = class {
 	/** 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.name = name;
 		this.config = {
@@ -866,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);
 		}
 	}
@@ -898,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);
@@ -961,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;
@@ -1200,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",
@@ -1217,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",
@@ -1262,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",
@@ -1374,6 +1450,8 @@ var FileTransport = class {
 	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.config = {
 			format: "json",
@@ -1462,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();
@@ -1473,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;
 	}
@@ -1557,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(),
@@ -1579,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) {
@@ -1747,6 +1857,7 @@ var FileTransport = class {
 			this.batchTimer = void 0;
 		}
 		await this.flush();
+		this.detachExitListener();
 		await this.housekeeping;
 		this.reportDropped(0);
 	}
@@ -1870,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)
@@ -2088,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",
@@ -2257,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",
@@ -2427,15 +2538,16 @@ 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.
@@ -2516,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;
@@ -2533,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,
@@ -2571,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);
@@ -2597,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 {
@@ -2641,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());
@@ -2661,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) => {
@@ -2997,4 +3250,4 @@ Object.defineProperty(exports, "stripControlChars", {
 	}
 });
 
-//# sourceMappingURL=otel-DH6-G6DR.js.map
+//# sourceMappingURL=otel-8ypFGG19.js.map