logixia 2.0.11 → 2.2.0

package/dist/transports.js

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_otel = require("./otel-DH6-G6DR.js");
-const require_slack_transport = require("./slack.transport-CEYBVzUj.js");
-const require_azure_monitor_transport = require("./azure-monitor.transport-C8KdmsSw.js");
-const require_cloudwatch_transport = require("./cloudwatch.transport-BoCyxNKO.js");
-const require_gcp_transport = require("./gcp.transport-D_NHVZrw.js");
-const require_worker_transport = require("./worker.transport-CwNpH98o.js");
+const require_otel = require("./otel-BrgvxLDW.js");
+const require_slack_transport = require("./slack.transport-Ci0swStG.js");
+const require_azure_monitor_transport = require("./azure-monitor.transport-Bl3xVvpN.js");
+const require_cloudwatch_transport = require("./cloudwatch.transport-DO9e__Z-.js");
+const require_gcp_transport = require("./gcp.transport-V9R4dwdT.js");
+const require_worker_transport = require("./worker.transport-CZOutlxC.js");
 exports.AnalyticsTransport = require_otel.AnalyticsTransport;
 exports.AzureMonitorTransport = require_azure_monitor_transport.AzureMonitorTransport;
 exports.CloudWatchTransport = require_cloudwatch_transport.CloudWatchTransport;
@@ -18,6 +18,7 @@ exports.GoogleAnalyticsTransport = require_otel.GoogleAnalyticsTransport;
 exports.MixpanelTransport = require_otel.MixpanelTransport;
 exports.OtlpLogTransport = require_slack_transport.OtlpLogTransport;
 exports.SegmentTransport = require_otel.SegmentTransport;
+exports.SentryTransport = require_slack_transport.SentryTransport;
 exports.SlackTransport = require_slack_transport.SlackTransport;
 exports.TransportManager = require_otel.TransportManager;
 exports.WorkerTransport = require_worker_transport.WorkerTransport;

package/dist/transports.mjs

@@ -1,7 +1,7 @@
-import { _ as ConsoleTransport, c as TransportManager, d as GoogleAnalyticsTransport, f as FileTransport, h as DatabaseTransport, l as SegmentTransport, m as AnalyticsTransport, p as DataDogTransport, u as MixpanelTransport } from "./otel-DAVxpArV.mjs";
-import { i as toOtelSeverity, n as DiscordTransport, r as OtlpLogTransport, t as SlackTransport } from "./slack.transport-YvaLJxNv.mjs";
-import { t as AzureMonitorTransport } from "./azure-monitor.transport-CTnfwA0F.mjs";
-import { t as CloudWatchTransport } from "./cloudwatch.transport-Bl1qzdBx.mjs";
-import { t as GCPTransport } from "./gcp.transport-DOH4bpWM.mjs";
-import { t as WorkerTransport } from "./worker.transport-DgK_ZXlB.mjs";
-export { AnalyticsTransport, AzureMonitorTransport, CloudWatchTransport, ConsoleTransport, DataDogTransport, DatabaseTransport, DiscordTransport, FileTransport, GCPTransport, GoogleAnalyticsTransport, MixpanelTransport, OtlpLogTransport, SegmentTransport, SlackTransport, TransportManager, WorkerTransport, toOtelSeverity };
+import { _ as ConsoleTransport, c as TransportManager, d as GoogleAnalyticsTransport, f as FileTransport, h as DatabaseTransport, l as SegmentTransport, m as AnalyticsTransport, p as DataDogTransport, u as MixpanelTransport } from "./otel-C5jBV_l_.mjs";
+import { a as toOtelSeverity, i as OtlpLogTransport, n as SentryTransport, r as DiscordTransport, t as SlackTransport } from "./slack.transport-C6dzPJHX.mjs";
+import { t as AzureMonitorTransport } from "./azure-monitor.transport-B_dqSV_o.mjs";
+import { t as CloudWatchTransport } from "./cloudwatch.transport-Brh5fmRN.mjs";
+import { t as GCPTransport } from "./gcp.transport-BY1Z3cS0.mjs";
+import { t as WorkerTransport } from "./worker.transport-CxFD8mvS.mjs";
+export { AnalyticsTransport, AzureMonitorTransport, CloudWatchTransport, ConsoleTransport, DataDogTransport, DatabaseTransport, DiscordTransport, FileTransport, GCPTransport, GoogleAnalyticsTransport, MixpanelTransport, OtlpLogTransport, SegmentTransport, SentryTransport, SlackTransport, TransportManager, WorkerTransport, toOtelSeverity };

package/dist/worker-entry.js

@@ -613,6 +613,19 @@ function viewOf(target) {
 	}
 	return view;
 }
+function protectedOwner(value) {
+	let target = value;
+	while (target !== null && !hiddenKeys.has(target)) target = Object.getPrototypeOf(target);
+	return target ?? value;
+}
+function protectedView() {
+	return viewOf(protectedOwner(this));
+}
+const VIEW_DESCRIPTOR = {
+	value: protectedView,
+	enumerable: false,
+	configurable: true
+};
 /**
 * Hides `keys` on `target` (assigned or not yet) and gives it a redacted `toJSON()` /
 * inspect view. Fields stay readable and writable. Safe to call more than once.
@@ -631,17 +644,8 @@ function protectSecrets(target, keys) {
 		values = /* @__PURE__ */ new Map();
 		hiddenKeys.set(target, hidden);
 		hiddenValues.set(target, values);
-		const view = () => viewOf(target);
-		Object.defineProperty(target, "toJSON", {
-			value: view,
-			enumerable: false,
-			configurable: true
-		});
-		Object.defineProperty(target, INSPECT_CUSTOM, {
-			value: view,
-			enumerable: false,
-			configurable: true
-		});
+		Object.defineProperty(target, "toJSON", VIEW_DESCRIPTOR);
+		Object.defineProperty(target, INSPECT_CUSTOM, VIEW_DESCRIPTOR);
 	}
 	const store = values;
 	for (const key of keys) {
@@ -781,6 +785,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) {
@@ -828,6 +833,8 @@ var DatabaseTransport = class {
 	connection;
 	isConnected = false;
 	connectionPromise;
+	connectFailures = 0;
+	nextConnectAt = 0;
 	cap;
 	constructor(config) {
 		this.config = config;
@@ -849,9 +856,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);
@@ -876,6 +886,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);
@@ -973,6 +984,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) => {
@@ -1009,6 +1052,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) {
@@ -1030,6 +1074,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) {
@@ -1050,6 +1095,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 });
@@ -1272,6 +1318,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();
@@ -1280,17 +1327,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;
 	}
@@ -1446,6 +1495,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",
@@ -1534,6 +1585,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();
@@ -1545,6 +1597,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;
 	}
@@ -1629,7 +1705,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(),
@@ -1651,9 +1731,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) {
@@ -1819,6 +1902,7 @@ var FileTransport = class {
 			this.batchTimer = void 0;
 		}
 		await this.flush();
+		this.detachExitListener();
 		await this.housekeeping;
 		this.reportDropped(0);
 	}

package/dist/worker.d.mts

@@ -1,2 +1,2 @@
-import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-Bl8lFRck.mjs";
+import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-DnU0_9Bd.mjs";
 export { WorkerTransport, WorkerTransportConfig };

package/dist/worker.d.ts

@@ -1,2 +1,2 @@
-import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-B9mCQSM1.js";
+import { n as WorkerTransportConfig, t as WorkerTransport } from "./worker.transport-B7olL1Uh.js";
 export { WorkerTransport, WorkerTransportConfig };

package/dist/worker.js

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_worker_transport = require("./worker.transport-CwNpH98o.js");
+const require_worker_transport = require("./worker.transport-CZOutlxC.js");
 exports.WorkerTransport = require_worker_transport.WorkerTransport;

package/dist/worker.mjs

@@ -1 +1 @@
-export { t as WorkerTransport } from "./worker.transport-DgK_ZXlB.mjs";
+export { t as WorkerTransport } from "./worker.transport-CxFD8mvS.mjs";

package/dist/{worker.transport-B9mCQSM1.d.ts → worker.transport-B7olL1Uh.d.ts}

@@ -1,4 +1,4 @@
-import { _ as TransportLogEntry, d as ITransport } from "./transport.types-CzJq4IrF.js";
+import { _ as TransportLogEntry, d as ITransport } from "./transport.types-B1ejJJP6.js";
 interface WorkerTransportConfig {
   /**
    * Which built-in logixia transport to run inside the worker thread.
@@ -49,11 +49,21 @@ declare class WorkerTransport implements ITransport {
   private restartTimer;
   /** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
   private closing;
+  /** Writes have been posted since the last flush; keeps the beforeExit flush from looping. */
+  private dirty;
+  /** Run once the worker reports ready, used when the process wants to exit before that. */
+  private onReady;
   /** Max time to wait for the worker's 'flushed' ack before giving up. */
   private readonly FLUSH_TIMEOUT_MS;
   /** Max time to wait for a graceful worker exit before force-terminating. */
   private readonly SHUTDOWN_TIMEOUT_MS;
   constructor(config: WorkerTransportConfig);
+  /**
+   * The worker is unref'd so it never keeps the process alive on its own; the
+   * trade-off is that lines still queued on it would be lost when the event loop
+   * drains. On beforeExit, re-ref the worker until it acknowledges a flush.
+   */
+  private readonly flushForExit;
   private startWorker;
   /** The worker entry is always built as CommonJS, next to this module's output. */
   protected workerFile(): string;
@@ -74,4 +84,4 @@ declare class WorkerTransport implements ITransport {
   private drainBufferTo;
 }
 export { WorkerTransportConfig as n, WorkerTransport as t };
-//# sourceMappingURL=worker.transport-B9mCQSM1.d.ts.map
+//# sourceMappingURL=worker.transport-B7olL1Uh.d.ts.map

package/dist/worker.transport-B7olL1Uh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.transport-B7olL1Uh.d.ts","names":[],"sources":["../src/transports/worker.transport.ts"],"mappings":";UA0CiB;;;;;EAKf;;EAEA,iBAAiB;;;;;;EAMjB;;;;;EAKA;;;;;EAKA,SAAS;;;;;EAKT;;;;;;cAOW,2BAA2B;WACtB;WACA;WACA;WACA;UAER;UACA;mBACS;mBACA;UACT;mBACS;mBACA;;UAET;;UAEA;;UAEA;;UAEA;;mBAES;;mBAEA;EAEL,YAAA,QAAQ;;;;;;mBAeH;UAgBT;;YA4CE;UAIF;UAuBA;EASR,MAAM,OAAO;EAaP,SAAS;;;;;;;;EAsCT,SAAS;;EAqCT,YAAY;UAIV"}

package/dist/{worker.transport-CwNpH98o.js → worker.transport-CZOutlxC.js}

@@ -1,4 +1,4 @@
-const require_secret_config = require("./secret-config-6hdODxBb.js");
+const require_secret_config = require("./secret-config-OqmIPmpV.js");
 const require_internal_log = require("./internal-log-DwqTjhpb.js");
 let node_path = require("node:path");
 node_path = require_secret_config.__toESM(node_path);
@@ -58,6 +58,10 @@ var WorkerTransport = class {
 	restartTimer = null;
 	/** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
 	closing = false;
+	/** Writes have been posted since the last flush; keeps the beforeExit flush from looping. */
+	dirty = false;
+	/** Run once the worker reports ready, used when the process wants to exit before that. */
+	onReady;
 	/** Max time to wait for the worker's 'flushed' ack before giving up. */
 	FLUSH_TIMEOUT_MS = 5e3;
 	/** Max time to wait for a graceful worker exit before force-terminating. */
@@ -69,7 +73,26 @@ var WorkerTransport = class {
 		this.level = config.level;
 		require_secret_config.protectSecrets(this, ["config"]);
 		this.startWorker();
+		process.on("beforeExit", this.flushForExit);
 	}
+	/**
+	* The worker is unref'd so it never keeps the process alive on its own; the
+	* trade-off is that lines still queued on it would be lost when the event loop
+	* drains. On beforeExit, re-ref the worker until it acknowledges a flush.
+	*/
+	flushForExit = () => {
+		var _worker$ref;
+		const worker = this.worker;
+		if (!worker || this.closing || !this.dirty) return;
+		(_worker$ref = worker.ref) === null || _worker$ref === void 0 || _worker$ref.call(worker);
+		const timer = setTimeout(() => worker.unref(), this.FLUSH_TIMEOUT_MS);
+		const done = () => {
+			clearTimeout(timer);
+			worker.unref();
+		};
+		if (this.ready) this.flush().finally(done);
+		else this.onReady = () => void this.flush().finally(done);
+	};
 	startWorker() {
 		try {
 			this.worker = new node_worker_threads.Worker(this.workerFile(), { workerData: {
@@ -81,6 +104,9 @@ var WorkerTransport = class {
 				if (msg.type === "ready") {
 					this.ready = true;
 					this.drainBuffer();
+					const onReady = this.onReady;
+					this.onReady = void 0;
+					onReady === null || onReady === void 0 || onReady();
 				} else if (msg.type === "error" || msg.type === "write-error") require_internal_log.internalError(`WorkerTransport [${this.config.transportType}]: ${msg.error ?? "unknown"}`);
 			});
 			this.worker.on("error", (err) => {
@@ -93,6 +119,7 @@ var WorkerTransport = class {
 					this.handleWorkerExit();
 				}
 			});
+			this.worker.unref();
 		} catch (err) {
 			require_internal_log.internalError("WorkerTransport failed to start", err);
 		}
@@ -124,6 +151,7 @@ var WorkerTransport = class {
 		}
 	}
 	write(entry) {
+		this.dirty = true;
 		if (this.ready && this.worker) this.worker.postMessage({
 			type: "write",
 			entry
@@ -137,18 +165,25 @@ var WorkerTransport = class {
 		}
 	}
 	async flush() {
+		var _worker$ref2;
 		if (!this.ready || !this.worker) return;
 		const worker = this.worker;
+		this.dirty = false;
+		(_worker$ref2 = worker.ref) === null || _worker$ref2 === void 0 || _worker$ref2.call(worker);
 		return new Promise((resolve) => {
 			const timer = setTimeout(() => {
+				var _worker$unref;
 				worker.off("message", handler);
+				(_worker$unref = worker.unref) === null || _worker$unref === void 0 || _worker$unref.call(worker);
 				resolve();
 			}, this.FLUSH_TIMEOUT_MS);
 			if (timer.unref) timer.unref();
 			const handler = (msg) => {
 				if (msg.type === "flushed") {
+					var _worker$unref2;
 					clearTimeout(timer);
 					worker.off("message", handler);
+					(_worker$unref2 = worker.unref) === null || _worker$unref2 === void 0 || _worker$unref2.call(worker);
 					resolve();
 				}
 			};
@@ -164,7 +199,9 @@ var WorkerTransport = class {
 	* graceful exit, leaking the worker thread and dropping its buffered logs.
 	*/
 	async close() {
+		var _worker$ref3;
 		this.closing = true;
+		process.removeListener("beforeExit", this.flushForExit);
 		if (this.restartTimer) {
 			clearTimeout(this.restartTimer);
 			this.restartTimer = null;
@@ -174,6 +211,7 @@ var WorkerTransport = class {
 		this.worker = null;
 		this.drainBufferTo(worker);
 		worker.postMessage({ type: "shutdown" });
+		(_worker$ref3 = worker.ref) === null || _worker$ref3 === void 0 || _worker$ref3.call(worker);
 		await new Promise((resolve) => {
 			const timer = setTimeout(() => {
 				worker.terminate().finally(() => resolve());
@@ -206,4 +244,4 @@ Object.defineProperty(exports, "WorkerTransport", {
 	}
 });
 
-//# sourceMappingURL=worker.transport-CwNpH98o.js.map
+//# sourceMappingURL=worker.transport-CZOutlxC.js.map

package/dist/worker.transport-CZOutlxC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.transport-CZOutlxC.js","names":["Worker","path"],"sources":["../src/transports/worker.transport.ts"],"sourcesContent":["/**\n * logixia — Worker Thread Transport\n *\n * Offloads JSON serialization and all I/O to a Node.js worker thread,\n * completely eliminating any event-loop impact from logging. The main thread\n * only posts a raw message to the worker — it never calls JSON.stringify or\n * any I/O syscalls on the hot path.\n *\n * Architecture:\n *   Main thread  →  MessageChannel  →  Worker thread  →  Wrapped transport\n *\n * The worker runs an ordinary logixia transport (file, database, console…)\n * inside its own event loop. If the worker crashes it is restarted automatically\n * (up to `maxRestarts` times) and buffered messages are replayed.\n *\n * @example\n * ```ts\n * import { WorkerTransport } from 'logixia/worker';\n *\n * const logger = createLogger({\n *   transports: {\n *     // Run file transport inside a worker thread — zero event-loop impact\n *     custom: [\n *       new WorkerTransport({\n *         transportType: 'file',\n *         transportConfig: { filename: 'app.log', dirname: './logs' },\n *         bufferSize: 500,\n *         maxRestarts: 3,\n *       }),\n *     ],\n *   },\n * });\n * ```\n */\n\nimport path from 'node:path';\nimport { Worker } from 'node:worker_threads';\n\nimport type { ITransport, TransportLogEntry } from '../types/transport.types';\nimport { internalError, internalWarn } from '../utils/internal-log';\nimport { protectSecrets } from './secret-config';\n\nexport interface WorkerTransportConfig {\n  /**\n   * Which built-in logixia transport to run inside the worker thread.\n   * The worker resolves the correct module automatically.\n   */\n  transportType: 'file' | 'database' | 'console';\n  /** Config forwarded verbatim to the wrapped transport constructor. */\n  transportConfig: Record<string, unknown>;\n  /**\n   * Max log entries to buffer in the main thread while the worker is starting\n   * or restarting. Entries beyond this limit are dropped with a warning.\n   * @default 1000\n   */\n  bufferSize?: number;\n  /**\n   * How many times to restart the worker if it crashes unexpectedly.\n   * @default 3\n   */\n  maxRestarts?: number;\n  /**\n   * Custom level severities (`levelOptions.levels`) the wrapped transport's own\n   * `level` is compared against inside the worker. Built-in levels need no entry.\n   */\n  levels?: Record<string, number>;\n  /**\n   * Log level filter — only entries at or above this level are forwarded.\n   * Useful for routing only errors to an expensive transport in a worker.\n   */\n  level?: string;\n}\n\n/**\n * Transport that runs a wrapped transport inside a dedicated Node.js worker\n * thread, completely removing JSON serialization and I/O from the main event loop.\n */\nexport class WorkerTransport implements ITransport {\n  public readonly name = 'worker';\n  public readonly level: string | undefined;\n  public readonly batchSize = 1;\n  public readonly flushInterval = 0;\n\n  private worker: Worker | null = null;\n  private ready = false;\n  private readonly buffer: TransportLogEntry[] = [];\n  private readonly bufferSize: number;\n  private restarts = 0;\n  private readonly maxRestarts: number;\n  private readonly config: WorkerTransportConfig;\n  /** Pending restart-backoff timer, so close() can cancel a queued restart. */\n  private restartTimer: NodeJS.Timeout | null = null;\n  /** Set once close() begins, so a worker 'exit' no longer triggers a restart. */\n  private closing = false;\n  /** Writes have been posted since the last flush; keeps the beforeExit flush from looping. */\n  private dirty = false;\n  /** Run once the worker reports ready, used when the process wants to exit before that. */\n  private onReady: (() => void) | undefined;\n  /** Max time to wait for the worker's 'flushed' ack before giving up. */\n  private readonly FLUSH_TIMEOUT_MS = 5000;\n  /** Max time to wait for a graceful worker exit before force-terminating. */\n  private readonly SHUTDOWN_TIMEOUT_MS = 5000;\n\n  constructor(config: WorkerTransportConfig) {\n    this.config = config;\n    this.bufferSize = config.bufferSize ?? 1000;\n    this.maxRestarts = config.maxRestarts ?? 3;\n    this.level = config.level;\n    protectSecrets(this, ['config']);\n    this.startWorker();\n    process.on('beforeExit', this.flushForExit);\n  }\n\n  /**\n   * The worker is unref'd so it never keeps the process alive on its own; the\n   * trade-off is that lines still queued on it would be lost when the event loop\n   * drains. On beforeExit, re-ref the worker until it acknowledges a flush.\n   */\n  private readonly flushForExit = (): void => {\n    const worker = this.worker;\n    if (!worker || this.closing || !this.dirty) return;\n    worker.ref?.();\n    const timer = setTimeout(() => worker.unref(), this.FLUSH_TIMEOUT_MS);\n    const done = (): void => {\n      clearTimeout(timer);\n      worker.unref();\n    };\n    if (this.ready) {\n      void this.flush().finally(done);\n    } else {\n      this.onReady = () => void this.flush().finally(done);\n    }\n  };\n\n  private startWorker(): void {\n    try {\n      this.worker = new Worker(this.workerFile(), {\n        workerData: {\n          transportType: this.config.transportType,\n          transportConfig: this.config.transportConfig,\n          levels: this.config.levels,\n        },\n      });\n\n      this.worker.on('message', (msg: { type: string; error?: string }) => {\n        if (msg.type === 'ready') {\n          this.ready = true;\n          this.drainBuffer();\n          const onReady = this.onReady;\n          this.onReady = undefined;\n          onReady?.();\n        } else if (msg.type === 'error' || msg.type === 'write-error') {\n          internalError(\n            `WorkerTransport [${this.config.transportType}]: ${msg.error ?? 'unknown'}`\n          );\n        }\n      });\n\n      this.worker.on('error', (err) => {\n        internalError('WorkerTransport worker error', err);\n        this.handleWorkerExit();\n      });\n\n      this.worker.on('exit', (code) => {\n        if (code !== 0) {\n          internalWarn(`WorkerTransport worker exited with code ${code}`);\n          this.handleWorkerExit();\n        }\n      });\n\n      // After the listeners: adding a 'message' listener re-refs the worker's port.\n      this.worker.unref();\n    } catch (err) {\n      internalError('WorkerTransport failed to start', err);\n    }\n  }\n\n  /** The worker entry is always built as CommonJS, next to this module's output. */\n  protected workerFile(): string {\n    return path.join(__dirname, 'worker-entry.js');\n  }\n\n  private handleWorkerExit(): void {\n    this.ready = false;\n    // Don't resurrect a worker we're intentionally shutting down — close() sets\n    // `closing` and nulls the worker, so a late 'exit'/'error' event must not\n    // queue a restart (which would spawn a fresh leaked thread post-shutdown).\n    if (this.closing) return;\n    if (this.restarts < this.maxRestarts) {\n      this.restarts++;\n      internalWarn(`WorkerTransport restarting (attempt ${this.restarts}/${this.maxRestarts})`);\n      // Small backoff before restart. unref() so a perpetually-failing worker's\n      // pending restart never keeps the process alive on its own.\n      this.restartTimer = setTimeout(() => {\n        this.restartTimer = null;\n        this.startWorker();\n      }, 500 * this.restarts);\n      if (this.restartTimer.unref) this.restartTimer.unref();\n    } else {\n      internalError(\n        `WorkerTransport exhausted ${this.maxRestarts} restart attempts — transport disabled`\n      );\n    }\n  }\n\n  private drainBuffer(): void {\n    while (this.buffer.length > 0 && this.ready && this.worker) {\n      const entry = this.buffer.shift();\n      if (entry) {\n        this.worker.postMessage({ type: 'write', entry });\n      }\n    }\n  }\n\n  write(entry: TransportLogEntry): void {\n    this.dirty = true;\n    if (this.ready && this.worker) {\n      this.worker.postMessage({ type: 'write', entry });\n    } else {\n      if (this.buffer.length >= this.bufferSize) {\n        internalWarn('WorkerTransport buffer full — dropping oldest entry');\n        this.buffer.shift();\n      }\n      this.buffer.push(entry);\n    }\n  }\n\n  async flush(): Promise<void> {\n    if (!this.ready || !this.worker) return;\n    const worker = this.worker;\n    this.dirty = false;\n    // Unref'd between flushes; ref'd here so an awaited flush() keeps the process alive.\n    worker.ref?.();\n    return new Promise<void>((resolve) => {\n      // Time-box the flush: if the worker dies or restarts before answering,\n      // the 'flushed' message would never arrive and this promise would hang\n      // forever, blocking shutdown until the force-exit timer kills the process\n      // (losing everything). Resolve on timeout so close() can still terminate.\n      const timer = setTimeout(() => {\n        worker.off('message', handler);\n        worker.unref?.();\n        resolve();\n      }, this.FLUSH_TIMEOUT_MS);\n      if (timer.unref) timer.unref();\n\n      const handler = (msg: { type: string }) => {\n        if (msg.type === 'flushed') {\n          clearTimeout(timer);\n          worker.off('message', handler);\n          worker.unref?.();\n          resolve();\n        }\n      };\n      worker.on('message', handler);\n      worker.postMessage({ type: 'flush' });\n    });\n  }\n\n  /**\n   * Flush the worker's buffer and terminate the thread on shutdown.\n   *\n   * This MUST be named close() — TransportManager.close() invokes\n   * transport.close(), so a method named only shutdown() was never called on\n   * graceful exit, leaking the worker thread and dropping its buffered logs.\n   */\n  async close(): Promise<void> {\n    // Stop the restart loop first: cancel any queued backoff restart and flag\n    // that further worker exits are expected (so handleWorkerExit no-ops).\n    this.closing = true;\n    process.removeListener('beforeExit', this.flushForExit);\n    if (this.restartTimer) {\n      clearTimeout(this.restartTimer);\n      this.restartTimer = null;\n    }\n\n    if (!this.worker) return;\n    const worker = this.worker;\n    this.worker = null;\n\n    // Push any locally-buffered (pre-ready) entries first: the worker's port\n    // queues them until its listener attaches, so they are handled before the\n    // shutdown message, which flushes the wrapped transport and exits.\n    this.drainBufferTo(worker);\n    worker.postMessage({ type: 'shutdown' });\n    // The worker is unref'd, so hold the process open until it has drained and exited.\n    worker.ref?.();\n\n    await new Promise<void>((resolve) => {\n      // Don't wait forever for a wedged worker — terminate() it after a timeout.\n      const timer = setTimeout(() => {\n        worker.terminate().finally(() => resolve());\n      }, this.SHUTDOWN_TIMEOUT_MS);\n      if (timer.unref) timer.unref();\n\n      worker.once('exit', () => {\n        clearTimeout(timer);\n        resolve();\n      });\n    });\n  }\n\n  /** Back-compat alias — prefer close(). */\n  async shutdown(): Promise<void> {\n    await this.close();\n  }\n\n  private drainBufferTo(worker: Worker): void {\n    while (this.buffer.length > 0) {\n      const entry = this.buffer.shift();\n      if (entry) worker.postMessage({ type: 'write', entry });\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/{worker.transport-DgK_ZXlB.mjs → worker.transport-CxFD8mvS.mjs}

@@ -1,4 +1,4 @@
-import { n as protectSecrets } from "./secret-config-D1F4MW69.mjs";
+import { n as protectSecrets } from "./secret-config-Cng7XPLx.mjs";
 import { r as internalWarn, t as internalError } from "./internal-log-Cy5nF1ZL.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -62,6 +62,10 @@ var WorkerTransport = class {
 	restartTimer = null;
 	/** Set once close() begins, so a worker 'exit' no longer triggers a restart. */
 	closing = false;
+	/** Writes have been posted since the last flush; keeps the beforeExit flush from looping. */
+	dirty = false;
+	/** Run once the worker reports ready, used when the process wants to exit before that. */
+	onReady;
 	/** Max time to wait for the worker's 'flushed' ack before giving up. */
 	FLUSH_TIMEOUT_MS = 5e3;
 	/** Max time to wait for a graceful worker exit before force-terminating. */
@@ -73,7 +77,26 @@ var WorkerTransport = class {
 		this.level = config.level;
 		protectSecrets(this, ["config"]);
 		this.startWorker();
+		process.on("beforeExit", this.flushForExit);
 	}
+	/**
+	* The worker is unref'd so it never keeps the process alive on its own; the
+	* trade-off is that lines still queued on it would be lost when the event loop
+	* drains. On beforeExit, re-ref the worker until it acknowledges a flush.
+	*/
+	flushForExit = () => {
+		var _worker$ref;
+		const worker = this.worker;
+		if (!worker || this.closing || !this.dirty) return;
+		(_worker$ref = worker.ref) === null || _worker$ref === void 0 || _worker$ref.call(worker);
+		const timer = setTimeout(() => worker.unref(), this.FLUSH_TIMEOUT_MS);
+		const done = () => {
+			clearTimeout(timer);
+			worker.unref();
+		};
+		if (this.ready) this.flush().finally(done);
+		else this.onReady = () => void this.flush().finally(done);
+	};
 	startWorker() {
 		try {
 			this.worker = new Worker(this.workerFile(), { workerData: {
@@ -85,6 +108,9 @@ var WorkerTransport = class {
 				if (msg.type === "ready") {
 					this.ready = true;
 					this.drainBuffer();
+					const onReady = this.onReady;
+					this.onReady = void 0;
+					onReady === null || onReady === void 0 || onReady();
 				} else if (msg.type === "error" || msg.type === "write-error") internalError(`WorkerTransport [${this.config.transportType}]: ${msg.error ?? "unknown"}`);
 			});
 			this.worker.on("error", (err) => {
@@ -97,6 +123,7 @@ var WorkerTransport = class {
 					this.handleWorkerExit();
 				}
 			});
+			this.worker.unref();
 		} catch (err) {
 			internalError("WorkerTransport failed to start", err);
 		}
@@ -128,6 +155,7 @@ var WorkerTransport = class {
 		}
 	}
 	write(entry) {
+		this.dirty = true;
 		if (this.ready && this.worker) this.worker.postMessage({
 			type: "write",
 			entry
@@ -141,18 +169,25 @@ var WorkerTransport = class {
 		}
 	}
 	async flush() {
+		var _worker$ref2;
 		if (!this.ready || !this.worker) return;
 		const worker = this.worker;
+		this.dirty = false;
+		(_worker$ref2 = worker.ref) === null || _worker$ref2 === void 0 || _worker$ref2.call(worker);
 		return new Promise((resolve) => {
 			const timer = setTimeout(() => {
+				var _worker$unref;
 				worker.off("message", handler);
+				(_worker$unref = worker.unref) === null || _worker$unref === void 0 || _worker$unref.call(worker);
 				resolve();
 			}, this.FLUSH_TIMEOUT_MS);
 			if (timer.unref) timer.unref();
 			const handler = (msg) => {
 				if (msg.type === "flushed") {
+					var _worker$unref2;
 					clearTimeout(timer);
 					worker.off("message", handler);
+					(_worker$unref2 = worker.unref) === null || _worker$unref2 === void 0 || _worker$unref2.call(worker);
 					resolve();
 				}
 			};
@@ -168,7 +203,9 @@ var WorkerTransport = class {
 	* graceful exit, leaking the worker thread and dropping its buffered logs.
 	*/
 	async close() {
+		var _worker$ref3;
 		this.closing = true;
+		process.removeListener("beforeExit", this.flushForExit);
 		if (this.restartTimer) {
 			clearTimeout(this.restartTimer);
 			this.restartTimer = null;
@@ -178,6 +215,7 @@ var WorkerTransport = class {
 		this.worker = null;
 		this.drainBufferTo(worker);
 		worker.postMessage({ type: "shutdown" });
+		(_worker$ref3 = worker.ref) === null || _worker$ref3 === void 0 || _worker$ref3.call(worker);
 		await new Promise((resolve) => {
 			const timer = setTimeout(() => {
 				worker.terminate().finally(() => resolve());
@@ -205,4 +243,4 @@ var WorkerTransport = class {
 };
 export { WorkerTransport as t };
 
-//# sourceMappingURL=worker.transport-DgK_ZXlB.mjs.map
+//# sourceMappingURL=worker.transport-CxFD8mvS.mjs.map