@loggerjs/node 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _loggerjs_core = require("@loggerjs/core");
 let fs = require("fs");
+let path = require("path");
 let node_zlib = require("node:zlib");
 let dgram = require("dgram");
 let net = require("net");
@@ -8,66 +9,116 @@ let os = require("os");
 let node_worker_threads = require("node:worker_threads");
 let node_async_hooks = require("node:async_hooks");
 let node_module = require("node:module");
-//#region src/stdout-transport.ts
+//#region src/node-destination.ts
+const encoder = new TextEncoder();
 const normalizeError = (error) => error instanceof Error ? error : new Error(String(error));
-function stdoutTransport(options = {}) {
-	const codec = options.codec ?? (0, _loggerjs_core.ndjsonCodec)();
-	const stream = options.stream ?? process.stdout;
-	const transportName = options.name ?? "stdout";
+function byteLength(payload) {
+	return typeof payload === "string" ? encoder.encode(payload).byteLength : payload.byteLength;
+}
+function coalescePayloads(payloads) {
+	if (payloads.every((payload) => typeof payload === "string")) return payloads.join("");
+	const buffers = payloads.map((payload) => typeof payload === "string" ? Buffer.from(payload) : Buffer.from(payload));
+	return Buffer.concat(buffers);
+}
+function isEpipe(error) {
+	return Boolean(error) && typeof error === "object" && error.code === "EPIPE";
+}
+function normalizeMinLength(value) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return 0;
+	return Math.floor(value);
+}
+function createNodeStreamDestination(options) {
+	const minLength = normalizeMinLength(options.minLength);
+	const ignoreEpipe = options.ignoreEpipe ?? false;
 	const waiters = [];
+	const buffer = [];
+	const pendingPayloads = [];
+	let bufferedBytes = 0;
 	let pendingWrites = 0;
 	let pendingDrains = 0;
 	let lastError;
 	let lastContext;
+	let closed = false;
 	const reportInternalError = (error, operation) => {
+		if (ignoreEpipe && isEpipe(error)) return;
 		lastContext?.reportInternalError(error, {
 			phase: "transport",
-			transport: transportName,
+			transport: options.name,
 			operation
 		});
 	};
 	const settleWaitersIfIdle = () => {
 		if (pendingWrites + pendingDrains > 0) return;
+		if (waiters.length === 0) return;
 		const error = lastError;
 		lastError = void 0;
 		for (const waiter of waiters.splice(0)) if (error) waiter.reject(error);
 		else waiter.resolve();
 	};
 	const recordError = (error, operation) => {
+		if (ignoreEpipe && isEpipe(error)) {
+			closed = true;
+			return;
+		}
 		lastError = normalizeError(error);
 		reportInternalError(lastError, operation);
 	};
+	const onStreamError = (error) => {
+		recordError(error, "stream-error");
+		settleWaitersIfIdle();
+	};
+	const offError = () => options.stream.off?.("error", onStreamError);
+	options.stream.on?.("error", onStreamError);
 	const waitForDrain = () => {
-		if (!stream.once) return;
+		if (!options.stream.once) return;
 		pendingDrains += 1;
-		stream.once("drain", () => {
+		options.stream.once("drain", () => {
 			pendingDrains -= 1;
 			settleWaitersIfIdle();
 		});
 	};
-	const writePayload = (payload) => {
+	const removePending = (payload) => {
+		const index = pendingPayloads.indexOf(payload);
+		if (index >= 0) pendingPayloads.splice(index, 1);
+	};
+	const writeNow = (payload) => {
+		if (closed) return;
+		pendingPayloads.push(payload);
 		pendingWrites += 1;
 		try {
-			if (stream.write(payload, (error) => {
+			if (options.stream.write(payload, (error) => {
+				removePending(payload);
 				pendingWrites -= 1;
-				if (error) recordError(error, "write");
+				if (error) recordError(error, options.reportOperation ?? "write");
 				settleWaitersIfIdle();
 			}) === false) waitForDrain();
 		} catch (error) {
+			removePending(payload);
 			pendingWrites -= 1;
-			recordError(error, "write");
+			recordError(error, options.reportOperation ?? "write");
 			settleWaitersIfIdle();
 		}
 	};
-	return {
-		name: transportName,
-		minLevel: options.minLevel,
-		log(event, context) {
-			if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) return;
+	const flushBuffered = () => {
+		if (buffer.length === 0) return;
+		const payload = coalescePayloads(buffer.splice(0));
+		bufferedBytes = 0;
+		writeNow(payload);
+	};
+	const destination = {
+		write(payload, context) {
+			if (closed) return;
 			lastContext = context;
-			writePayload(codec.encode(event));
+			if (minLength > 0) {
+				buffer.push(payload);
+				bufferedBytes += byteLength(payload);
+				if (bufferedBytes >= minLength) flushBuffered();
+				return;
+			}
+			writeNow(payload);
 		},
 		flush() {
+			flushBuffered();
 			if (pendingWrites + pendingDrains === 0) {
 				const error = lastError;
 				lastError = void 0;
@@ -80,8 +131,133 @@ function stdoutTransport(options = {}) {
 					reject
 				});
 			});
+		},
+		flushSync() {
+			if (!options.syncWrite) {
+				flushBuffered();
+				return;
+			}
+			for (const payload of buffer.splice(0)) options.syncWrite(payload);
+			bufferedBytes = 0;
+			for (const payload of pendingPayloads.splice(0)) options.syncWrite(payload);
+		},
+		close() {
+			return destination.flush().then(() => new Promise((resolve, reject) => {
+				if (!options.stream.end) {
+					closed = true;
+					offError();
+					resolve();
+					return;
+				}
+				options.stream.end((error) => {
+					closed = true;
+					offError();
+					if (error && !(ignoreEpipe && isEpipe(error))) reject(error);
+					else resolve();
+				});
+			}), (error) => {
+				offError();
+				return Promise.reject(error);
+			});
+		},
+		closeSync() {
+			destination.flushSync();
+			closed = true;
+			offError();
+		}
+	};
+	return destination;
+}
+function createNodeFileDestination(options) {
+	const flags = options.flags ?? (options.append === false ? "w" : "a");
+	if (options.mkdir) (0, fs.mkdirSync)((0, path.dirname)(options.path), { recursive: true });
+	let fd;
+	const getFd = () => {
+		fd ??= (0, fs.openSync)(options.path, flags);
+		return fd;
+	};
+	const syncWrite = (payload) => {
+		if (typeof payload === "string") (0, fs.writeSync)(getFd(), payload);
+		else (0, fs.writeSync)(getFd(), payload);
+	};
+	if (options.sync) {
+		let closed = false;
+		const releaseSync = () => {
+			if (fd !== void 0) {
+				(0, fs.closeSync)(fd);
+				fd = void 0;
+			}
+		};
+		return {
+			write(payload) {
+				if (closed) return;
+				syncWrite(payload);
+			},
+			flush() {
+				return Promise.resolve();
+			},
+			flushSync() {},
+			close() {
+				releaseSync();
+				closed = true;
+				return Promise.resolve();
+			},
+			closeSync() {
+				releaseSync();
+				closed = true;
+			},
+			releaseSync
+		};
+	}
+	const stream = (0, fs.createWriteStream)(options.path, { flags });
+	const destination = createNodeStreamDestination({
+		name: options.name,
+		stream,
+		minLength: options.minLength,
+		syncWrite
+	});
+	const releaseSync = () => {
+		if (fd !== void 0) {
+			(0, fs.closeSync)(fd);
+			fd = void 0;
 		}
 	};
+	return {
+		...destination,
+		stream,
+		close() {
+			return destination.close().finally(releaseSync);
+		},
+		closeSync() {
+			destination.closeSync();
+			releaseSync();
+		},
+		releaseSync
+	};
+}
+//#endregion
+//#region src/stdout-transport.ts
+function stdoutTransport(options = {}) {
+	const codec = options.codec ?? (0, _loggerjs_core.ndjsonCodec)();
+	const stream = options.stream ?? process.stdout;
+	const transportName = options.name ?? "stdout";
+	const destination = createNodeStreamDestination({
+		name: transportName,
+		stream,
+		minLength: options.minLength,
+		ignoreEpipe: options.ignoreEpipe ?? true
+	});
+	return {
+		name: transportName,
+		minLevel: options.minLevel,
+		log(event, context) {
+			if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) return;
+			destination.write(codec.encode(event), context);
+		},
+		flush: destination.flush,
+		flushSync: destination.flushSync,
+		close: destination.close
+	};
 }
 function stderrTransport(options = {}) {
 	return stdoutTransport({
@@ -94,60 +270,26 @@ function stderrTransport(options = {}) {
 //#region src/file-transport.ts
 function fileTransport(options) {
 	const codec = options.codec ?? (0, _loggerjs_core.ndjsonCodec)();
-	const flags = options.flags ?? "a";
-	const stream = (0, fs.createWriteStream)(options.path, { flags });
-	let syncFd;
-	const pending = [];
-	const removePending = (payload) => {
-		const index = pending.indexOf(payload);
-		if (index >= 0) pending.splice(index, 1);
-	};
-	const getSyncFd = () => {
-		syncFd ??= (0, fs.openSync)(options.path, flags);
-		return syncFd;
-	};
+	const destination = createNodeFileDestination({
+		name: options.name ?? "file",
+		path: options.path,
+		flags: options.flags,
+		append: options.append,
+		mkdir: options.mkdir,
+		sync: options.sync,
+		minLength: options.minLength
+	});
 	return {
 		name: options.name ?? "file",
 		minLevel: options.minLevel,
-		stream,
-		log(event) {
+		stream: destination.stream,
+		log(event, context) {
 			if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) return;
-			const payload = codec.encode(event);
-			pending.push(payload);
-			stream.write(payload, (error) => {
-				if (!error) removePending(payload);
-			});
+			destination.write(codec.encode(event), context);
 		},
-		flush() {
-			return new Promise((resolve, reject) => {
-				stream.write("", (error) => {
-					if (error) {
-						reject(error);
-						return;
-					}
-					pending.splice(0, pending.length);
-					resolve();
-				});
-			});
-		},
-		flushSync() {
-			if (pending.length === 0) return;
-			const fd = getSyncFd();
-			for (const payload of pending.splice(0)) if (typeof payload === "string") (0, fs.writeSync)(fd, payload);
-			else (0, fs.writeSync)(fd, payload);
-		},
-		close() {
-			return new Promise((resolve, reject) => {
-				stream.end?.((error) => {
-					if (syncFd !== void 0) {
-						(0, fs.closeSync)(syncFd);
-						syncFd = void 0;
-					}
-					if (error) reject(error);
-					else resolve();
-				});
-			});
-		}
+		flush: destination.flush,
+		flushSync: destination.flushSync,
+		close: destination.close
 	};
 }
 //#endregion
@@ -176,23 +318,20 @@ function fileSize(path) {
 }
 function rotatingFileTransport(options) {
 	const codec = options.codec ?? (0, _loggerjs_core.ndjsonCodec)();
-	const flags = options.flags ?? "a";
 	const maxBytes = normalizePositiveInteger(options.maxBytes, 10 * 1024 * 1024);
 	const maxFiles = normalizeNonNegativeInteger(options.maxFiles, 5);
 	const archivePath = options.archivePath ?? defaultArchivePath;
-	let fd;
+	const destination = createNodeFileDestination({
+		name: options.name ?? "rotating-file",
+		path: options.path,
+		flags: options.flags,
+		append: options.append,
+		mkdir: options.mkdir,
+		sync: true
+	});
 	let bytes = fileSize(options.path);
-	const closeFd = () => {
-		if (fd === void 0) return;
-		(0, fs.closeSync)(fd);
-		fd = void 0;
-	};
-	const getFd = () => {
-		fd ??= (0, fs.openSync)(options.path, flags);
-		return fd;
-	};
 	const rotate = () => {
-		closeFd();
+		destination.releaseSync?.();
 		if (maxFiles === 0) {
 			if ((0, fs.existsSync)(options.path)) (0, fs.unlinkSync)(options.path);
 			bytes = 0;
@@ -210,8 +349,7 @@ function rotatingFileTransport(options) {
 	const writePayload = (payload) => {
 		const size = payloadBytes(payload);
 		if (bytes > 0 && bytes + size > maxBytes) rotate();
-		if (typeof payload === "string") (0, fs.writeSync)(getFd(), payload);
-		else (0, fs.writeSync)(getFd(), payload);
+		destination.write(payload);
 		bytes += size;
 	};
 	return {
@@ -228,12 +366,11 @@ function rotatingFileTransport(options) {
 			}
 		},
 		flush() {
-			return Promise.resolve();
+			return destination.flush();
 		},
-		flushSync() {},
+		flushSync: destination.flushSync,
 		close() {
-			closeFd();
-			return Promise.resolve();
+			return destination.close();
 		},
 		rotate,
 		currentBytes: () => bytes
@@ -455,13 +592,58 @@ function transferablePayload(payload) {
 		transferList: [copy.buffer]
 	};
 }
+function normalizePositiveTimeout(value) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return 0;
+	return Math.floor(value);
+}
+function protocolMessage(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const message = value;
+	if (message.type === "loggerjs:ready") return { type: "loggerjs:ready" };
+	if (message.type === "loggerjs:batch:ack") {
+		const id = value.id;
+		if (typeof id === "number") return {
+			type: "loggerjs:batch:ack",
+			id
+		};
+	}
+	if (message.type === "loggerjs:error") {
+		const item = value;
+		return {
+			type: "loggerjs:error",
+			error: item.error,
+			message: typeof item.message === "string" ? item.message : void 0
+		};
+	}
+}
+function dropBatch(events, reason) {
+	(0, _loggerjs_core.incrementLoggerMetaCounter)("transport.dropped", events.length);
+	(0, _loggerjs_core.incrementLoggerMetaCounter)(`transport.dropped.${reason}`, events.length);
+}
 function workerTransport(options = {}) {
 	const codec = options.codec ?? (0, _loggerjs_core.safeJsonCodec)();
 	const transportName = options.name ?? "worker";
 	const fallback = options.fallback;
+	const readyTimeoutMs = normalizePositiveTimeout(options.readyTimeoutMs);
+	const ackTimeoutMs = normalizePositiveTimeout(options.ackTimeoutMs);
+	const autoEnd = options.autoEnd ?? true;
 	let worker;
 	let failed = false;
+	let failedError;
 	let lastContext;
+	let ready = readyTimeoutMs === 0;
+	let readyPromise;
+	let readyTimer;
+	let readyResolve;
+	let readyReject;
+	let nextBatchId = 1;
+	const pendingBatches = /* @__PURE__ */ new Map();
+	const setPendingGauge = () => {
+		(0, _loggerjs_core.setLoggerMetaGauge)(`transport.queue.depth.${transportName}`, pendingBatches.size);
+	};
+	const setReadyGauge = (value) => {
+		(0, _loggerjs_core.setLoggerMetaGauge)(`transport.ready.${transportName}`, value);
+	};
 	const reportInternalError = (error, operation) => {
 		lastContext?.reportInternalError(error, {
 			phase: "transport",
@@ -470,14 +652,82 @@ function workerTransport(options = {}) {
 		});
 	};
 	const markFailed = (error, operation) => {
+		if (failed) return;
 		failed = true;
+		failedError = error instanceof Error ? error : new Error(String(error));
+		setReadyGauge(0);
 		(0, _loggerjs_core.incrementLoggerMetaCounter)("transport.worker.failed");
+		(0, _loggerjs_core.emitLoggerDiagnostic)({
+			stage: "worker",
+			phase: "error",
+			transport: transportName,
+			operation,
+			error
+		});
 		reportInternalError(error, operation);
+		readyReject?.(failedError);
+		failPendingBatches(operation);
 	};
 	const onWorkerError = (error) => markFailed(error, "worker-error");
 	const onWorkerExit = (code) => {
 		if (typeof code === "number" && code !== 0) markFailed(code, "worker-exit");
 	};
+	const onWorkerMessage = (value) => {
+		const message = protocolMessage(value);
+		if (!message) return;
+		if (message.type === "loggerjs:ready") {
+			ready = true;
+			setReadyGauge(1);
+			(0, _loggerjs_core.emitLoggerDiagnostic)({
+				stage: "worker",
+				phase: "end",
+				transport: transportName,
+				operation: "ready"
+			});
+			if (readyTimer) clearTimeout(readyTimer);
+			readyResolve?.();
+			return;
+		}
+		if (message.type === "loggerjs:batch:ack") {
+			const pending = pendingBatches.get(message.id);
+			if (!pending) return;
+			pendingBatches.delete(message.id);
+			setPendingGauge();
+			if (pending.timer) clearTimeout(pending.timer);
+			pending.resolve();
+			(0, _loggerjs_core.incrementLoggerMetaCounter)("transport.worker.ack");
+			return;
+		}
+		markFailed(message.error ?? new Error(message.message ?? "Worker reported an error"), "worker-message");
+	};
+	const fallbackOrDropBatch = async (events, context, reason) => {
+		if (fallback) {
+			await fallbackBatch(events, context);
+			return;
+		}
+		dropBatch(events, reason);
+	};
+	const failPendingBatch = (pending, reason) => {
+		pendingBatches.delete(pending.id);
+		setPendingGauge();
+		if (pending.timer) clearTimeout(pending.timer);
+		(0, _loggerjs_core.incrementLoggerMetaCounter)("transport.worker.pending-dropped", pending.events.length);
+		fallbackOrDropBatch(pending.events, pending.context, reason).finally(pending.resolve);
+	};
+	function failPendingBatches(reason) {
+		for (const pending of Array.from(pendingBatches.values())) failPendingBatch(pending, reason);
+	}
+	const waitForReady = async () => {
+		if (ready) return;
+		readyPromise ??= new Promise((resolve, reject) => {
+			readyResolve = resolve;
+			readyReject = reject;
+			readyTimer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`workerTransport ready timeout after ${readyTimeoutMs}ms`));
+			}, readyTimeoutMs);
+		});
+		await readyPromise;
+	};
 	const getWorker = () => {
 		if (failed) return void 0;
 		if (worker) return worker;
@@ -485,6 +735,8 @@ function workerTransport(options = {}) {
 			worker = options.worker ?? options.workerFactory?.() ?? createDefaultWorker(options);
 			worker.on?.("error", onWorkerError);
 			worker.on?.("exit", onWorkerExit);
+			worker.on?.("message", onWorkerMessage);
+			if (ready) setReadyGauge(1);
 			return worker;
 		} catch (error) {
 			markFailed(error, "create-worker");
@@ -502,7 +754,14 @@ function workerTransport(options = {}) {
 		lastContext = context;
 		const currentWorker = getWorker();
 		if (!currentWorker) {
-			await fallbackBatch(events, context);
+			await fallbackOrDropBatch(events, context, "worker-unavailable");
+			return;
+		}
+		try {
+			await waitForReady();
+		} catch (error) {
+			markFailed(error, "worker-ready-timeout");
+			await fallbackOrDropBatch(events, context, "worker-ready-timeout");
 			return;
 		}
 		const encoded = payloadToBytes(codec.encode(events));
@@ -517,16 +776,53 @@ function workerTransport(options = {}) {
 			count: events.length,
 			payload: transferable.payload
 		};
+		let pending;
+		if (ackTimeoutMs > 0) {
+			const id = nextBatchId;
+			nextBatchId += 1;
+			message.id = id;
+			pending = {
+				id,
+				events,
+				context,
+				resolve: () => {}
+			};
+			pending.timer = setTimeout(() => {
+				if (!pending) return;
+				markFailed(/* @__PURE__ */ new Error(`workerTransport ack timeout after ${ackTimeoutMs}ms`), "worker-ack-timeout");
+			}, ackTimeoutMs);
+			pendingBatches.set(id, pending);
+			setPendingGauge();
+		}
 		try {
 			currentWorker.postMessage(message, transferable.transferList);
 		} catch (error) {
 			markFailed(error, "post-message");
-			await fallbackBatch(events, context);
+			if (!pending) await fallbackOrDropBatch(events, context, "worker-post-message");
 		}
 	};
-	return {
+	const transport = {
 		name: transportName,
 		minLevel: options.minLevel,
+		async ready() {
+			if (!getWorker()) {
+				if (fallback) {
+					await fallback.ready?.();
+					return;
+				}
+				throw failedError ?? /* @__PURE__ */ new Error("workerTransport is unavailable");
+			}
+			try {
+				await waitForReady();
+			} catch (error) {
+				markFailed(error, "worker-ready-timeout");
+				if (fallback) {
+					await fallback.ready?.();
+					return;
+				}
+				throw error;
+			}
+		},
 		log(event, context) {
 			if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) return;
 			return postBatch([event], context);
@@ -535,15 +831,28 @@ function workerTransport(options = {}) {
 			return postBatch(events, context);
 		},
 		async flush() {
+			await Promise.all(Array.from(pendingBatches.values(), (pending) => new Promise((resolve) => {
+				const originalResolve = pending.resolve;
+				pending.resolve = () => {
+					originalResolve();
+					resolve();
+				};
+			})));
 			await fallback?.flush?.();
 		},
 		async close() {
+			await transport.flush?.();
 			worker?.off?.("error", onWorkerError);
 			worker?.off?.("exit", onWorkerExit);
+			worker?.off?.("message", onWorkerMessage);
 			await fallback?.close?.();
-			await worker?.terminate?.();
+			if (autoEnd) await worker?.terminate?.();
+			if (readyTimer) clearTimeout(readyTimer);
+			readyReject = void 0;
+			readyResolve = void 0;
 		}
 	};
+	return transport;
 }
 //#endregion
 //#region src/context.ts
@@ -1441,16 +1750,16 @@ function nodeFetchIntegration(options = {}) {
 }
 //#endregion
 //#region src/node-http-client-integration.ts
-const requireBuiltin$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const requireBuiltin$2 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 const defaultRandom$1 = () => Math.random();
 let cachedHttpModule;
 let cachedHttpsModule;
 function loadBuiltin(name, fallback) {
 	try {
-		return requireBuiltin$1(name);
+		return requireBuiltin$2(name);
 	} catch {
 		try {
-			return requireBuiltin$1(fallback);
+			return requireBuiltin$2(fallback);
 		} catch {
 			return null;
 		}
@@ -1915,15 +2224,15 @@ const defaultChannels = [
 	"undici:request:trailers",
 	"undici:request:error"
 ];
-const requireBuiltin = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-let cachedDiagnosticsChannel;
+const requireBuiltin$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+let cachedDiagnosticsChannel$1;
 function diagnosticsChannelIntegration(options = {}) {
 	const channels = options.channels ?? defaultChannels;
 	const captureMessage = options.captureMessage ?? false;
 	return {
 		name: "diagnostics-channel",
 		setup(api) {
-			const diagnosticsChannel = options.diagnosticsChannel === void 0 ? loadDiagnosticsChannel() : options.diagnosticsChannel;
+			const diagnosticsChannel = options.diagnosticsChannel === void 0 ? loadDiagnosticsChannel$1() : options.diagnosticsChannel;
 			if (!diagnosticsChannel) return;
 			const disposers = [];
 			let disposed = false;
@@ -1950,6 +2259,23 @@ function diagnosticsChannelIntegration(options = {}) {
 		}
 	};
 }
+function loadDiagnosticsChannel$1() {
+	if (cachedDiagnosticsChannel$1 !== void 0) return cachedDiagnosticsChannel$1;
+	try {
+		cachedDiagnosticsChannel$1 = requireBuiltin$1("node:diagnostics_channel");
+	} catch {
+		try {
+			cachedDiagnosticsChannel$1 = requireBuiltin$1("diagnostics_channel");
+		} catch {
+			cachedDiagnosticsChannel$1 = null;
+		}
+	}
+	return cachedDiagnosticsChannel$1;
+}
+//#endregion
+//#region src/logger-diagnostics.ts
+const requireBuiltin = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+let cachedDiagnosticsChannel;
 function loadDiagnosticsChannel() {
 	if (cachedDiagnosticsChannel !== void 0) return cachedDiagnosticsChannel;
 	try {
@@ -1963,6 +2289,29 @@ function loadDiagnosticsChannel() {
 	}
 	return cachedDiagnosticsChannel;
 }
+function installLoggerDiagnosticsChannel(options = {}) {
+	const diagnosticsChannel = options.diagnosticsChannel === void 0 ? loadDiagnosticsChannel() : options.diagnosticsChannel;
+	if (!diagnosticsChannel) return () => {};
+	const prefix = options.prefix ?? "loggerjs";
+	const channels = /* @__PURE__ */ new Map();
+	const channelFor = (stage) => {
+		const name = `${prefix}.${stage}`;
+		let channel = channels.get(name);
+		if (!channel) {
+			channel = diagnosticsChannel.channel(name);
+			channels.set(name, channel);
+		}
+		return channel;
+	};
+	const sink = (event) => {
+		channelFor(event.stage).publish(event);
+	};
+	sink.enabled = (stage) => channelFor(stage).hasSubscribers !== false;
+	const previous = (0, _loggerjs_core.setLoggerDiagnosticSink)(sink);
+	return () => {
+		(0, _loggerjs_core.setLoggerDiagnosticSink)(previous);
+	};
+}
 //#endregion
 exports.bullMqIntegration = bullMqIntegration;
 exports.captureCliIntegration = captureCliIntegration;
@@ -1976,6 +2325,7 @@ exports.fileTransport = fileTransport;
 exports.formatSyslogMessage = formatSyslogMessage;
 exports.hapiIntegration = hapiIntegration;
 exports.installAsyncLocalStorageContext = installAsyncLocalStorageContext;
+exports.installLoggerDiagnosticsChannel = installLoggerDiagnosticsChannel;
 exports.koaIntegration = koaIntegration;
 exports.nestMiddlewareIntegration = nestMiddlewareIntegration;
 exports.nodeCompressionPayloadTransform = nodeCompressionPayloadTransform;