logixia 1.10.2 → 1.10.3

package/dist/{transport.manager-CaL4XuLD.mjs → transport.manager-Cij_sA-b.mjs}

@@ -3,7 +3,9 @@ import { EventEmitter } from "node:events";
 import * as readline from "node:readline";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
+import { createGzip } from "node:zlib";
 
 //#region rolldown:runtime
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -21,28 +23,36 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 * helpers instead so that internal output can be silenced in tests by setting
 * the LOGIXIA_SILENT_INTERNAL=1 environment variable.
 */
-const silent = process.env.LOGIXIA_SILENT_INTERNAL === "1";
+/**
+* Read the silence flag on each call rather than caching it at import time, so
+* setting LOGIXIA_SILENT_INTERNAL=1 AFTER the module is first imported (e.g. in
+* a test setup file) still takes effect — the documented test-silencing
+* behavior was previously unreliable because the value was frozen at load.
+*/
+function isSilent() {
+	return process.env.LOGIXIA_SILENT_INTERNAL === "1";
+}
 /**
 * Emit an internal debug/info message to stderr.
 * Use for field-enable/disable notifications that a developer might want to see
 * during development but should not appear in production log streams.
 */
 function internalLog(message) {
-	if (!silent) process.stderr.write(`[logixia] ${message}\n`);
+	if (!isSilent()) process.stderr.write(`[logixia] ${message}\n`);
 }
 /**
 * Emit an internal warning to stderr.
 * Use when something is misconfigured but logixia can continue operating.
 */
 function internalWarn(message) {
-	if (!silent) process.stderr.write(`[logixia:warn] ${message}\n`);
+	if (!isSilent()) process.stderr.write(`[logixia:warn] ${message}\n`);
 }
 /**
 * Emit an internal error to stderr.
 * Use when a transport write fails or a serious internal error occurs.
 */
 function internalError(message, error) {
-	if (!silent) {
+	if (!isSilent()) {
 		let errStr = "";
 		if (error instanceof Error) errStr = ` — ${error.message}`;
 		else if (error != null) errStr = ` — ${String(error)}`;
@@ -72,6 +82,7 @@ function internalError(message, error) {
 *   `String(value)` for circular refs / values without a stringifier.
 */
 function safeToString(value) {
+	var _constructor;
 	if (typeof value === "string") return value;
 	if (value === void 0 || value === null) return "";
 	if (value instanceof Error) return value.message;
@@ -79,11 +90,10 @@ function safeToString(value) {
 	if (typeof value === "symbol") return value.toString();
 	if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
 	try {
-		return JSON.stringify(value);
-	} catch {
-		var _constructor;
-		return `[${((_constructor = value.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "object"}]`;
-	}
+		const json = JSON.stringify(value);
+		if (json !== void 0) return json;
+	} catch {}
+	return `[${((_constructor = value.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) ?? "object"}]`;
 }
 
 //#endregion
@@ -216,7 +226,6 @@ var DatabaseTransport = class {
 		this.config = config;
 		this.name = "database";
 		this.batch = [];
-		this.isFlushing = false;
 		this.isConnected = false;
 		this.batchSize = config.batchSize || 100;
 		this.flushInterval = config.flushInterval || 5e3;
@@ -233,33 +242,44 @@ var DatabaseTransport = class {
 		this.batch.push(entry);
 	}
 	async flush() {
-		if (this.batch.length === 0) return;
-		if (this.isFlushing) return;
-		this.isFlushing = true;
-		const entriesToFlush = [...this.batch];
-		this.batch = [];
-		try {
-			switch (this.config.type) {
-				case "mongodb":
-					await this.flushToMongoDB(entriesToFlush);
-					break;
-				case "postgresql":
-					await this.flushToPostgreSQL(entriesToFlush);
-					break;
-				case "mysql":
-					await this.flushToMySQL(entriesToFlush);
-					break;
-				case "sqlite":
-					await this.flushToSQLite(entriesToFlush);
-					break;
-				default: throw new Error(`Unsupported database type: ${this.config.type}`);
+		if (!this.flushPromise) this.flushPromise = this.drain().finally(() => {
+			this.flushPromise = void 0;
+		});
+		await this.flushPromise;
+	}
+	/**
+	* Drains the batch to the database one snapshot at a time. The current batch
+	* is detached SYNCHRONOUSLY before awaiting the write, so entries appended by
+	* concurrent write() calls land in a fresh array and are never written twice.
+	* On write failure the snapshot is restored to the front of the batch for the
+	* next flush cycle and the loop stops, so a persistently failing DB does not
+	* hot-spin retrying the same entries.
+	*/
+	async drain() {
+		while (this.batch.length > 0) {
+			const entriesToFlush = this.batch;
+			this.batch = [];
+			try {
+				switch (this.config.type) {
+					case "mongodb":
+						await this.flushToMongoDB(entriesToFlush);
+						break;
+					case "postgresql":
+						await this.flushToPostgreSQL(entriesToFlush);
+						break;
+					case "mysql":
+						await this.flushToMySQL(entriesToFlush);
+						break;
+					case "sqlite":
+						await this.flushToSQLite(entriesToFlush);
+						break;
+					default: throw new Error(`Unsupported database type: ${this.config.type}`);
+				}
+			} catch (error) {
+				internalError("Database flush error", error);
+				this.batch.unshift(...entriesToFlush);
+				throw error;
 			}
-		} catch (error) {
-			internalError("Database flush error", error);
-			this.batch.unshift(...entriesToFlush);
-			throw error;
-		} finally {
-			this.isFlushing = false;
 		}
 	}
 	async isReady() {
@@ -272,7 +292,10 @@ var DatabaseTransport = class {
 	}
 	async connect() {
 		if (this.connectionPromise) return this.connectionPromise;
-		this.connectionPromise = this.establishConnection();
+		this.connectionPromise = this.establishConnection().catch((error) => {
+			this.connectionPromise = void 0;
+			throw error;
+		});
 		return this.connectionPromise;
 	}
 	async establishConnection() {
@@ -503,8 +526,17 @@ var DatabaseTransport = class {
 		}, this.flushInterval);
 	}
 	async close() {
-		if (this.flushTimer) clearInterval(this.flushTimer);
-		await this.flush();
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = void 0;
+		}
+		const MAX_CLOSE_FLUSH_ATTEMPTS = 3;
+		for (let attempt = 0; attempt < MAX_CLOSE_FLUSH_ATTEMPTS && this.batch.length > 0; attempt += 1) try {
+			await this.flush();
+		} catch (error) {
+			internalError("Database flush during close failed; entries remain buffered", error);
+		}
+		if (this.batch.length > 0) internalError(`Database transport closing with ${this.batch.length} unflushed log entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
 		if (this.connection) switch (this.config.type) {
 			case "mongodb":
 				await this.connection.close();
@@ -540,7 +572,8 @@ var DatabaseTransport = class {
 					var _result$rows, _result$;
 					const tableName = this.config.table || "logs";
 					const result = await this.connection.query(`SELECT COUNT(*) as count FROM ${tableName}`);
-					return ((_result$rows = result.rows) === null || _result$rows === void 0 || (_result$rows = _result$rows[0]) === null || _result$rows === void 0 ? void 0 : _result$rows.count) || ((_result$ = result[0]) === null || _result$ === void 0 ? void 0 : _result$.count) || 0;
+					const rawCount = ((_result$rows = result.rows) === null || _result$rows === void 0 || (_result$rows = _result$rows[0]) === null || _result$rows === void 0 ? void 0 : _result$rows.count) ?? ((_result$ = result[0]) === null || _result$ === void 0 ? void 0 : _result$.count) ?? 0;
+					return Number(rawCount) || 0;
 				}
 				default: return 0;
 			}
@@ -583,23 +616,43 @@ var AnalyticsTransport = class {
 		}, this.config.flushInterval);
 	}
 	async flush() {
-		if (this.batch.length === 0) return;
-		const entriesToSend = [...this.batch];
-		this.batch = [];
 		if (this.batchTimer) {
 			clearTimeout(this.batchTimer);
-			delete this.batchTimer;
+			this.batchTimer = void 0;
 		}
-		try {
-			await this.sendBatch(entriesToSend);
-		} catch (error) {
-			internalError(`Analytics transport ${this.name} flush failed`, error);
-			this.batch.unshift(...entriesToSend);
+		if (!this.flushPromise) this.flushPromise = this.drain().finally(() => {
+			this.flushPromise = void 0;
+		});
+		await this.flushPromise;
+	}
+	/**
+	* Drains the batch to the provider one snapshot at a time. The batch is
+	* detached SYNCHRONOUSLY before awaiting sendBatch(), so entries appended by
+	* concurrent writes land in a fresh array and are never sent twice. On failure
+	* the snapshot is restored to the front of the batch for the next flush and
+	* the loop stops, so a failing provider does not hot-spin.
+	*/
+	async drain() {
+		while (this.batch.length > 0) {
+			const entriesToSend = this.batch;
+			this.batch = [];
+			try {
+				await this.sendBatch(entriesToSend);
+			} catch (error) {
+				internalError(`Analytics transport ${this.name} flush failed`, error);
+				this.batch.unshift(...entriesToSend);
+				return;
+			}
 		}
 	}
 	async close() {
-		await this.flush();
-		if (this.batchTimer) clearTimeout(this.batchTimer);
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = void 0;
+		}
+		const MAX_CLOSE_FLUSH_ATTEMPTS = 3;
+		for (let attempt = 0; attempt < MAX_CLOSE_FLUSH_ATTEMPTS && this.batch.length > 0; attempt += 1) await this.flush();
+		if (this.batch.length > 0) internalError(`Analytics transport ${this.name} closing with ${this.batch.length} unflushed entr${this.batch.length === 1 ? "y" : "ies"} after ${MAX_CLOSE_FLUSH_ATTEMPTS} attempts`);
 		await this.cleanup();
 	}
 	shouldSkipEntry(entry) {
@@ -1025,15 +1078,34 @@ var FileTransport = class {
 			await mkdir(dir, { recursive: true });
 		} catch {}
 	}
-	async compressFile(_filePath) {}
+	/**
+	* Gzip the rotated file to `<file>.gz` and remove the original. Streams the
+	* data so large log files don't have to be buffered in memory. Best-effort:
+	* any failure is logged and leaves the original file intact rather than
+	* throwing out of the rotation path.
+	*/
+	async compressFile(filePath) {
+		const gzPath = `${filePath}.gz`;
+		try {
+			await pipeline(fs.createReadStream(filePath), createGzip(), fs.createWriteStream(gzPath));
+			await unlink(filePath);
+		} catch (error) {
+			internalError("Failed to compress rotated log file", error);
+			try {
+				await unlink(gzPath);
+			} catch {}
+		}
+	}
 	async cleanupOldFiles() {
 		var _this$config$rotation4;
 		if (!((_this$config$rotation4 = this.config.rotation) === null || _this$config$rotation4 === void 0 ? void 0 : _this$config$rotation4.maxFiles)) return;
 		try {
 			const dir = this.resolveDir();
 			const files = await readdir(dir);
-			const base = path.basename(this.config.filename, path.extname(this.config.filename));
-			const logFiles = files.filter((file) => file.startsWith(base)).map(async (file) => {
+			const ext = path.extname(this.config.filename);
+			const base = path.basename(this.config.filename, ext);
+			const isOwnRotatedFile = (file) => file.startsWith(`${base}-`) && (file.endsWith(ext) || file.endsWith(`${ext}.gz`));
+			const logFiles = files.filter(isOwnRotatedFile).map(async (file) => {
 				const filePath = path.join(dir, file);
 				return {
 					path: filePath,
@@ -1834,7 +1906,7 @@ var TransportManager = class extends EventEmitter {
 			const writeTime = Date.now() - startTime;
 			metrics.logsWritten++;
 			metrics.lastWrite = new Date(startTime);
-			metrics.averageWriteTime = (metrics.averageWriteTime + writeTime) / 2;
+			metrics.averageWriteTime += (writeTime - metrics.averageWriteTime) / metrics.logsWritten;
 			this.emit("log", entry);
 		} catch (error) {
 			metrics.errors++;
@@ -2062,4 +2134,4 @@ var TransportManager = class extends EventEmitter {
 
 //#endregion
 export { FileTransport as a, DatabaseTransport as c, internalError as d, internalLog as f, GoogleAnalyticsTransport as i, ConsoleTransport as l, __require as m, SegmentTransport as n, DataDogTransport as o, internalWarn as p, MixpanelTransport as r, AnalyticsTransport as s, TransportManager as t, safeToString as u };
-//# sourceMappingURL=transport.manager-CaL4XuLD.mjs.map
+//# sourceMappingURL=transport.manager-Cij_sA-b.mjs.map