@loggerjs/node 0.0.2 → 0.3.0

package/dist/index.cjs

@@ -1,72 +1,124 @@
 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");
 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;
@@ -79,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({
@@ -93,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);
-			});
-		},
-		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);
+			destination.write(codec.encode(event), context);
 		},
-		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
@@ -175,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;
@@ -209,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 {
@@ -227,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
@@ -252,13 +390,19 @@ function nodeHttpTransport(options) {
 		minLevel: options.minLevel,
 		async logBatch(events) {
 			if (!fetchFn) throw new Error("fetch is not available. Use Node.js 18+ or pass fetchFn.");
+			const transformed = await (0, _loggerjs_core.applyPayloadTransforms)(codec.encode(events), {
+				contentType: codec.contentType,
+				events,
+				transport: options.name ?? "node-http"
+			}, options.transformPayload);
 			const response = await fetchFn(options.url, {
 				method: options.method ?? "POST",
 				headers: {
-					"content-type": codec.contentType,
+					"content-type": transformed.contentType,
+					...transformed.headers,
 					...options.headers
 				},
-				body: payloadToBody(codec.encode(events))
+				body: payloadToBody(transformed.payload)
 			});
 			if (!response.ok) throw new Error(`nodeHttpTransport failed with status ${response.status}`);
 		}
@@ -283,6 +427,29 @@ function nodeHttpTransport(options) {
 	});
 }
 //#endregion
+//#region src/payload-transforms.ts
+const contentEncodingByFormat = {
+	gzip: "gzip",
+	brotli: "br",
+	deflate: "deflate"
+};
+function compressPayload(payload, format, options) {
+	const input = (0, _loggerjs_core.encodedPayloadToUint8Array)(payload);
+	if (format === "brotli") return Uint8Array.from((0, node_zlib.brotliCompressSync)(input, options.brotliOptions));
+	if (format === "deflate") return Uint8Array.from((0, node_zlib.deflateSync)(input, options.deflateOptions));
+	return Uint8Array.from((0, node_zlib.gzipSync)(input, options.gzipOptions));
+}
+function nodeCompressionPayloadTransform(options = {}) {
+	const format = options.format ?? "gzip";
+	return (payload) => ({
+		payload: compressPayload(payload, format, options),
+		headers: {
+			"content-encoding": contentEncodingByFormat[format],
+			...options.headers
+		}
+	});
+}
+//#endregion
 //#region src/syslog-transport.ts
 const severityByLevel = {
 	trace: 7,
@@ -425,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",
@@ -440,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;
@@ -455,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");
@@ -472,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));
@@ -487,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);
@@ -505,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
@@ -546,6 +885,170 @@ function installAsyncLocalStorageContext(manager = createAsyncLocalStorageContex
 	};
 }
 //#endregion
+//#region src/queue-integration.ts
+const defaultMethods$1 = [
+	"add",
+	"ack",
+	"consume",
+	"dequeue",
+	"nack",
+	"process",
+	"publish",
+	"receive",
+	"send",
+	"sendToQueue"
+];
+const defaultRandom$6 = () => Math.random();
+function defaultLevel$6(_durationMs, error) {
+	return error ? "error" : "debug";
+}
+function isPromiseLike$2(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function defaultOperation$1(method) {
+	switch (method) {
+		case "add":
+		case "publish":
+		case "send":
+		case "sendToQueue": return "publish";
+		case "consume":
+		case "dequeue":
+		case "process":
+		case "receive": return "consume";
+		case "ack": return "ack";
+		case "nack": return "nack";
+		default: return "other";
+	}
+}
+function defaultPayload(args) {
+	return typeof args[0] === "string" && args.length > 1 ? args[1] : args[0];
+}
+function defaultMessageId(args) {
+	const payload = defaultPayload(args);
+	if (typeof payload !== "object" || payload === null) return void 0;
+	const value = payload.messageId ?? payload.id;
+	return value === void 0 ? void 0 : String(value);
+}
+function payloadFor(args, method, options) {
+	if (!options.capturePayload) return void 0;
+	const payload = options.getPayload?.(args, method) ?? defaultPayload(args);
+	return payload === void 0 ? void 0 : (0, _loggerjs_core.normalizeValue)(payload, {
+		maxDepth: 4,
+		maxObjectKeys: 80
+	});
+}
+function queueIntegration(options = {}) {
+	const targets = options.targets ?? (options.client ? [{
+		client: options.client,
+		name: options.name,
+		system: options.system,
+		queueName: options.queueName,
+		methods: options.methods
+	}] : []);
+	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
+	const sampleRate = options.sampleRate ?? 1;
+	const random = options.random ?? defaultRandom$6;
+	const levelFor = options.level ?? defaultLevel$6;
+	const shouldCapture = (durationMs, error) => {
+		if (error) return true;
+		if (options.minDurationMs !== void 0 && durationMs >= options.minDurationMs) return true;
+		if (!captureAll) return false;
+		return sampleRate >= 1 || random() < sampleRate;
+	};
+	return {
+		name: "queue",
+		setup(api) {
+			const capture = api.guard((input) => api.capture(input));
+			const disposers = [];
+			let disposed = false;
+			const captureResult = (info, started, args, error) => {
+				const durationMs = Date.now() - started;
+				if (disposed || !shouldCapture(durationMs, error)) return;
+				capture({
+					level: levelFor(durationMs, error, info),
+					message: error ? `Queue error ${info.operation} ${info.queueName ?? info.method}` : `Queue ${info.operation} ${info.queueName ?? info.method}`,
+					error,
+					props: { queue: {
+						kind: info.target,
+						system: info.system,
+						queueName: info.queueName,
+						method: info.method,
+						operation: info.operation,
+						durationMs,
+						messageId: options.getMessageId?.(args, info.method) ?? defaultMessageId(args),
+						payload: payloadFor(args, info.method, options)
+					} }
+				});
+			};
+			for (const target of targets) {
+				const methods = target.methods ?? options.methods ?? defaultMethods$1;
+				for (const method of methods) {
+					const original = target.client[method];
+					if (typeof original !== "function") continue;
+					const originalMethod = original;
+					const targetName = target.name ?? options.name ?? "queue";
+					const system = target.system ?? options.system;
+					target.client[method] = function wrappedQueueMethod(...args) {
+						const started = Date.now();
+						const operation = options.getOperation?.(method, args) ?? defaultOperation$1(method);
+						const info = {
+							target: targetName,
+							system,
+							queueName: options.getQueueName?.(args, method) ?? target.queueName ?? options.queueName ?? (typeof args[0] === "string" ? args[0] : void 0),
+							method,
+							operation
+						};
+						try {
+							const result = originalMethod.apply(this, args);
+							if (isPromiseLike$2(result)) return result.then((value) => {
+								captureResult(info, started, args, void 0);
+								return value;
+							}, (error) => {
+								captureResult(info, started, args, error);
+								throw error;
+							});
+							captureResult(info, started, args, void 0);
+							return result;
+						} catch (error) {
+							captureResult(info, started, args, error);
+							throw error;
+						}
+					};
+					disposers.push(() => {
+						target.client[method] = originalMethod;
+					});
+				}
+			}
+			return () => {
+				if (disposed) return;
+				disposed = true;
+				for (const dispose of disposers) dispose();
+			};
+		}
+	};
+}
+//#endregion
+//#region src/bullmq-integration.ts
+const bullMqMethods = [
+	"add",
+	"addBulk",
+	"process"
+];
+function queueName(args, fallback) {
+	const first = args[0];
+	return typeof first === "string" ? first : fallback;
+}
+function bullMqIntegration(options) {
+	return queueIntegration({
+		...options,
+		name: options.name ?? "bullmq",
+		system: "bullmq",
+		methods: options.methods ?? bullMqMethods,
+		queueName: options.queueName ?? options.client.name,
+		getQueueName: (args) => queueName(args, options.queueName ?? options.client.name)
+	});
+}
+//#endregion
 //#region src/cli-integration.ts
 const defaultSignals = ["SIGINT", "SIGTERM"];
 function defaultProcess() {
@@ -558,7 +1061,7 @@ function defaultSanitizeArg(arg) {
 function defaultCommand(argv) {
 	return argv[1] ?? argv[0];
 }
-function levelFor(level, event, code) {
+function levelFor$2(level, event, code) {
 	if (typeof level === "function") return level(event, code);
 	if (level) return level;
 	if (event === "signal") return "warn";
@@ -611,7 +1114,7 @@ function captureCliIntegration(options = {}) {
 				env: pickEnv(processLike.env, options.captureEnv)
 			};
 			if (captureStart) capture({
-				level: levelFor(options.level, "start"),
+				level: levelFor$2(options.level, "start"),
 				message: `CLI start${command ? ` ${command}` : ""}`,
 				props: { cli: {
 					...cliBase,
@@ -622,7 +1125,7 @@ function captureCliIntegration(options = {}) {
 				const onExit = (code) => {
 					const exitCode = code ?? processLike.exitCode ?? 0;
 					capture({
-						level: levelFor(options.level, "exit", exitCode),
+						level: levelFor$2(options.level, "exit", exitCode),
 						message: `CLI exit ${String(exitCode)}`,
 						props: { cli: {
 							...cliBase,
@@ -637,7 +1140,7 @@ function captureCliIntegration(options = {}) {
 			if (captureSignals && processLike.on) for (const signal of signals) {
 				const onSignal = () => {
 					capture({
-						level: levelFor(options.level, "signal", signal),
+						level: levelFor$2(options.level, "signal", signal),
 						message: `CLI signal ${signal}`,
 						props: { cli: {
 							...cliBase,
@@ -659,18 +1162,18 @@ function captureCliIntegration(options = {}) {
 }
 //#endregion
 //#region src/database-integration.ts
-const defaultMethods$1 = [
+const defaultMethods = [
 	"query",
 	"execute",
 	"run",
 	"all",
 	"get"
 ];
-const defaultRandom$6 = () => Math.random();
-function defaultLevel$6(_durationMs, error) {
+const defaultRandom$5 = () => Math.random();
+function defaultLevel$5(_durationMs, error) {
 	return error ? "error" : "debug";
 }
-function isPromiseLike$2(value) {
+function isPromiseLike$1(value) {
 	return typeof value === "object" && value !== null && typeof value.then === "function";
 }
 function defaultStatement(args) {
@@ -704,8 +1207,8 @@ function databaseIntegration(options = {}) {
 	}] : []);
 	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
 	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? defaultRandom$6;
-	const levelFor = options.level ?? defaultLevel$6;
+	const random = options.random ?? defaultRandom$5;
+	const levelFor = options.level ?? defaultLevel$5;
 	const shouldCapture = (durationMs, error) => {
 		if (error) return true;
 		if (options.minDurationMs !== void 0 && durationMs >= options.minDurationMs) return true;
@@ -736,7 +1239,7 @@ function databaseIntegration(options = {}) {
 				});
 			};
 			for (const target of targets) {
-				const methods = target.methods ?? options.methods ?? defaultMethods$1;
+				const methods = target.methods ?? options.methods ?? defaultMethods;
 				for (const method of methods) {
 					const original = target.client[method];
 					if (typeof original !== "function") continue;
@@ -753,7 +1256,7 @@ function databaseIntegration(options = {}) {
 						};
 						try {
 							const result = originalMethod.apply(this, args);
-							if (isPromiseLike$2(result)) return result.then((value) => {
+							if (isPromiseLike$1(result)) return result.then((value) => {
 								captureResult(info, started, args, void 0);
 								return value;
 							}, (error) => {
@@ -782,14 +1285,14 @@ function databaseIntegration(options = {}) {
 }
 //#endregion
 //#region src/express-integration.ts
-const defaultRandom$5 = () => Math.random();
+const defaultRandom$4 = () => Math.random();
 function defaultSanitizeUrl$3(url) {
 	const queryIndex = url.indexOf("?");
 	const hashIndex = url.indexOf("#");
 	const end = Math.min(queryIndex >= 0 ? queryIndex : url.length, hashIndex >= 0 ? hashIndex : url.length);
 	return url.slice(0, end);
 }
-function defaultLevel$5(status, _req, _res, aborted) {
+function defaultLevel$4(status, _req, _res, aborted) {
 	if (aborted) return "warn";
 	if (status >= 500) return "error";
 	if (status >= 400) return "warn";
@@ -844,9 +1347,9 @@ function expressIntegration(logger, options = {}) {
 	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
 	const captureAborted = options.captureAborted ?? true;
 	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? defaultRandom$5;
+	const random = options.random ?? defaultRandom$4;
 	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl$3;
-	const levelFor = options.level ?? defaultLevel$5;
+	const levelFor = options.level ?? defaultLevel$4;
 	const routeFor = options.getRoute ?? defaultRoute$1;
 	const bindContext = options.bindContext ?? true;
 	return (req, res, next) => {
@@ -907,14 +1410,14 @@ function expressIntegration(logger, options = {}) {
 }
 //#endregion
 //#region src/fastify-integration.ts
-const defaultRandom$4 = () => Math.random();
+const defaultRandom$3 = () => Math.random();
 function defaultSanitizeUrl$2(url) {
 	const queryIndex = url.indexOf("?");
 	const hashIndex = url.indexOf("#");
 	const end = Math.min(queryIndex >= 0 ? queryIndex : url.length, hashIndex >= 0 ? hashIndex : url.length);
 	return url.slice(0, end);
 }
-function defaultLevel$4(status, _request, _reply, error) {
+function defaultLevel$3(status, _request, _reply, error) {
 	if (error || status >= 500) return "error";
 	if (status >= 400) return "warn";
 	return "info";
@@ -949,9 +1452,9 @@ function fastifyIntegration(logger, options = {}) {
 	const minStatus = options.minStatus ?? 400;
 	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
 	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? defaultRandom$4;
+	const random = options.random ?? defaultRandom$3;
 	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl$2;
-	const levelFor = options.level ?? defaultLevel$4;
+	const levelFor = options.level ?? defaultLevel$3;
 	const routeFor = options.getRoute ?? defaultRoute;
 	const bindContext = options.bindContext ?? true;
 	const states = /* @__PURE__ */ new WeakMap();
@@ -1021,15 +1524,131 @@ function fastifyIntegration(logger, options = {}) {
 	};
 }
 //#endregion
+//#region src/hapi-integration.ts
+function responseStatus(response) {
+	if (!response) return 200;
+	if ("statusCode" in response && typeof response.statusCode === "number") return response.statusCode;
+	if ("output" in response && typeof response.output?.statusCode === "number") return response.output.statusCode;
+	return 200;
+}
+function levelFor$1(status) {
+	if (status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function hapiIntegration(logger, options = {}) {
+	const minStatus = options.minStatus ?? 400;
+	const captureAll = options.captureAll ?? false;
+	const bindContext = options.bindContext ?? true;
+	const getLevel = options.level ?? levelFor$1;
+	return {
+		name: "loggerjs-hapi",
+		register(server) {
+			server.ext("onRequest", (request, h) => {
+				const context = {
+					httpMethod: (request.method ?? "GET").toUpperCase(),
+					httpUrl: request.url?.pathname ?? request.path ?? "/",
+					requestId: options.getRequestId?.(request) ?? request.info?.id,
+					...options.context?.(request)
+				};
+				request.app = {
+					...request.app,
+					loggerjsStartedAt: Date.now()
+				};
+				if (bindContext) return (0, _loggerjs_core.withContext)(context, () => h.continue);
+				return h.continue;
+			});
+			server.events?.on?.("response", (request) => {
+				const status = responseStatus(request.response);
+				if (!captureAll && status < minStatus) return;
+				const method = (request.method ?? "GET").toUpperCase();
+				const url = request.url?.pathname ?? request.path ?? "/";
+				const requestId = options.getRequestId?.(request) ?? request.info?.id;
+				const started = request.app?.loggerjsStartedAt;
+				logger.log(getLevel(status, request), `Hapi ${status} ${method} ${url}`, { http: {
+					framework: "hapi",
+					kind: "hapi",
+					method,
+					url,
+					status,
+					durationMs: started ? Date.now() - started : void 0,
+					requestId,
+					remoteAddress: request.info?.remoteAddress
+				} });
+			});
+		}
+	};
+}
+//#endregion
+//#region src/koa-integration.ts
+function sanitizeUrl(url) {
+	return url.split(/[?#]/, 1)[0] || "/";
+}
+function levelFor(status, _ctx, error) {
+	if (error || status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function koaIntegration(logger, options = {}) {
+	const minStatus = options.minStatus ?? 400;
+	const captureAll = options.captureAll ?? false;
+	const bindContext = options.bindContext ?? true;
+	const sanitize = options.sanitizeUrl ?? sanitizeUrl;
+	const getLevel = options.level ?? levelFor;
+	return async (ctx, next) => {
+		const started = Date.now();
+		const method = (ctx.method ?? "GET").toUpperCase();
+		const url = sanitize(ctx.originalUrl ?? ctx.url ?? ctx.path ?? "/");
+		const requestId = options.getRequestId?.(ctx) ?? ctx.state?.requestId;
+		const context = {
+			httpMethod: method,
+			httpUrl: url,
+			requestId,
+			...options.context?.(ctx)
+		};
+		let error;
+		try {
+			if (bindContext) await (0, _loggerjs_core.withContext)(context, next);
+			else await next();
+		} catch (caught) {
+			error = caught;
+			throw caught;
+		} finally {
+			const status = ctx.status ?? (error ? 500 : 200);
+			if (error || captureAll || status >= minStatus) logger.log(getLevel(status, ctx, error), `Koa ${status} ${method} ${url}`, {
+				http: {
+					framework: "koa",
+					kind: "koa",
+					method,
+					url,
+					status,
+					durationMs: Date.now() - started,
+					requestId,
+					remoteAddress: ctx.ip
+				},
+				error
+			});
+		}
+	};
+}
+//#endregion
+//#region src/nest-integration.ts
+function nestMiddlewareIntegration(logger, options = {}) {
+	return expressIntegration(logger, {
+		name: "nestjs",
+		...options
+	});
+}
+//#endregion
 //#region src/node-fetch-integration.ts
-const defaultRandom$3 = () => Math.random();
+const defaultRandom$2 = () => Math.random();
 function defaultSanitizeUrl$1(url) {
 	const queryIndex = url.indexOf("?");
 	const hashIndex = url.indexOf("#");
 	const end = Math.min(queryIndex >= 0 ? queryIndex : url.length, hashIndex >= 0 ? hashIndex : url.length);
 	return url.slice(0, end);
 }
-function defaultLevel$3(status, error) {
+function defaultLevel$2(status, error) {
 	if (error || status === void 0 || status >= 500) return "error";
 	if (status >= 400) return "warn";
 	return "info";
@@ -1072,9 +1691,9 @@ function nodeFetchIntegration(options = {}) {
 	const minStatus = options.minStatus ?? 400;
 	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
 	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? defaultRandom$3;
+	const random = options.random ?? defaultRandom$2;
 	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl$1;
-	const levelFor = options.level ?? defaultLevel$3;
+	const levelFor = options.level ?? defaultLevel$2;
 	const shouldCapture = (status, error) => {
 		if (error) return true;
 		if (status !== void 0 && status >= minStatus) return true;
@@ -1131,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 defaultRandom$2 = () => Math.random();
+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;
 		}
@@ -1162,7 +1781,7 @@ function defaultSanitizeUrl(url) {
 	const end = Math.min(queryIndex >= 0 ? queryIndex : url.length, hashIndex >= 0 ? hashIndex : url.length);
 	return url.slice(0, end);
 }
-function defaultLevel$2(status, error) {
+function defaultLevel$1(status, error) {
 	if (error || status === void 0 || status >= 500) return "error";
 	if (status >= 400) return "warn";
 	return "info";
@@ -1247,9 +1866,9 @@ function nodeHttpClientIntegration(options = {}) {
 	const minStatus = options.minStatus ?? 400;
 	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
 	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? defaultRandom$2;
+	const random = options.random ?? defaultRandom$1;
 	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl;
-	const levelFor = options.level ?? defaultLevel$2;
+	const levelFor = options.level ?? defaultLevel$1;
 	const shouldCapture = (status, error) => {
 		if (error) return true;
 		if (status !== void 0 && status >= minStatus) return true;
@@ -1319,12 +1938,19 @@ function nodeHttpClientIntegration(options = {}) {
 }
 //#endregion
 //#region src/process-integration.ts
+const signalExitCodes = {
+	SIGINT: 130,
+	SIGTERM: 143
+};
 function captureProcessIntegration(options = {}) {
 	const uncaughtException = options.uncaughtException ?? true;
 	const unhandledRejection = options.unhandledRejection ?? true;
 	const warning = options.warning ?? true;
 	const beforeExitFlush = options.beforeExitFlush ?? true;
 	const exitFlush = options.exitFlush ?? true;
+	const signalFlush = options.signalFlush ?? true;
+	const signals = options.signals ?? ["SIGTERM"];
+	const exitOnSignal = options.exitOnSignal ?? true;
 	const exitOnUncaught = options.exitOnUncaught ?? true;
 	const flushTimeoutMs = options.flushTimeoutMs ?? 250;
 	const exitFn = options.exitFn ?? ((code) => process.exit(code));
@@ -1414,6 +2040,23 @@ function captureProcessIntegration(options = {}) {
 				process.on("exit", onExit);
 				disposers.push(() => process.off("exit", onExit));
 			}
+			if (signalFlush) for (const signal of signals) {
+				const onSignal = () => {
+					capture({
+						level: "fatal",
+						message: `Process signal ${signal}`,
+						props: { process: {
+							kind: "signal",
+							signal
+						} }
+					});
+					flushSync();
+					const flushed = flushBounded();
+					if (exitOnSignal) flushed.finally(() => exitFn(signalExitCodes[signal] ?? 1));
+				};
+				process.on(signal, onSignal);
+				disposers.push(() => process.off(signal, onSignal));
+			}
 			return () => {
 				if (disposed) return;
 				disposed = true;
@@ -1423,148 +2066,53 @@ function captureProcessIntegration(options = {}) {
 	};
 }
 //#endregion
-//#region src/queue-integration.ts
-const defaultMethods = [
-	"add",
-	"ack",
-	"consume",
-	"dequeue",
-	"nack",
-	"process",
-	"publish",
-	"receive",
-	"send",
-	"sendToQueue"
+//#region src/prisma-integration.ts
+const prismaMethods = [
+	"$executeRaw",
+	"$executeRawUnsafe",
+	"$queryRaw",
+	"$queryRawUnsafe"
 ];
-const defaultRandom$1 = () => Math.random();
-function defaultLevel$1(_durationMs, error) {
-	return error ? "error" : "debug";
-}
-function isPromiseLike$1(value) {
-	return typeof value === "object" && value !== null && typeof value.then === "function";
-}
-function defaultOperation$1(method) {
-	switch (method) {
-		case "add":
-		case "publish":
-		case "send":
-		case "sendToQueue": return "publish";
-		case "consume":
-		case "dequeue":
-		case "process":
-		case "receive": return "consume";
-		case "ack": return "ack";
-		case "nack": return "nack";
-		default: return "other";
-	}
+function prismaStatement(args) {
+	const first = args[0];
+	if (typeof first === "string") return first;
+	if (Array.isArray(first) && "raw" in first) return first.raw?.join("?");
 }
-function defaultPayload(args) {
-	return typeof args[0] === "string" && args.length > 1 ? args[1] : args[0];
+function prismaIntegration(options) {
+	return databaseIntegration({
+		...options,
+		name: options.name ?? "prisma",
+		system: "prisma",
+		methods: prismaMethods,
+		getStatement: prismaStatement
+	});
 }
-function defaultMessageId(args) {
-	const payload = defaultPayload(args);
-	if (typeof payload !== "object" || payload === null) return void 0;
-	const value = payload.messageId ?? payload.id;
-	return value === void 0 ? void 0 : String(value);
+//#endregion
+//#region src/redis-integration.ts
+const redisMethods = [
+	"del",
+	"get",
+	"hget",
+	"hset",
+	"lpush",
+	"publish",
+	"rpush",
+	"set",
+	"xadd"
+];
+function redisStatement(args, method) {
+	const key = args[0] === void 0 ? "" : ` ${String(args[0])}`;
+	return `${method.toUpperCase()}${key}`;
 }
-function payloadFor(args, method, options) {
-	if (!options.capturePayload) return void 0;
-	const payload = options.getPayload?.(args, method) ?? defaultPayload(args);
-	return payload === void 0 ? void 0 : (0, _loggerjs_core.normalizeValue)(payload, {
-		maxDepth: 4,
-		maxObjectKeys: 80
+function redisIntegration(options) {
+	return databaseIntegration({
+		...options,
+		name: options.name ?? "redis",
+		system: "redis",
+		methods: options.methods ?? redisMethods,
+		getStatement: redisStatement
 	});
 }
-function queueIntegration(options = {}) {
-	const targets = options.targets ?? (options.client ? [{
-		client: options.client,
-		name: options.name,
-		system: options.system,
-		queueName: options.queueName,
-		methods: options.methods
-	}] : []);
-	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
-	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? defaultRandom$1;
-	const levelFor = options.level ?? defaultLevel$1;
-	const shouldCapture = (durationMs, error) => {
-		if (error) return true;
-		if (options.minDurationMs !== void 0 && durationMs >= options.minDurationMs) return true;
-		if (!captureAll) return false;
-		return sampleRate >= 1 || random() < sampleRate;
-	};
-	return {
-		name: "queue",
-		setup(api) {
-			const capture = api.guard((input) => api.capture(input));
-			const disposers = [];
-			let disposed = false;
-			const captureResult = (info, started, args, error) => {
-				const durationMs = Date.now() - started;
-				if (disposed || !shouldCapture(durationMs, error)) return;
-				capture({
-					level: levelFor(durationMs, error, info),
-					message: error ? `Queue error ${info.operation} ${info.queueName ?? info.method}` : `Queue ${info.operation} ${info.queueName ?? info.method}`,
-					error,
-					props: { queue: {
-						kind: info.target,
-						system: info.system,
-						queueName: info.queueName,
-						method: info.method,
-						operation: info.operation,
-						durationMs,
-						messageId: options.getMessageId?.(args, info.method) ?? defaultMessageId(args),
-						payload: payloadFor(args, info.method, options)
-					} }
-				});
-			};
-			for (const target of targets) {
-				const methods = target.methods ?? options.methods ?? defaultMethods;
-				for (const method of methods) {
-					const original = target.client[method];
-					if (typeof original !== "function") continue;
-					const originalMethod = original;
-					const targetName = target.name ?? options.name ?? "queue";
-					const system = target.system ?? options.system;
-					target.client[method] = function wrappedQueueMethod(...args) {
-						const started = Date.now();
-						const operation = options.getOperation?.(method, args) ?? defaultOperation$1(method);
-						const info = {
-							target: targetName,
-							system,
-							queueName: options.getQueueName?.(args, method) ?? target.queueName ?? options.queueName ?? (typeof args[0] === "string" ? args[0] : void 0),
-							method,
-							operation
-						};
-						try {
-							const result = originalMethod.apply(this, args);
-							if (isPromiseLike$1(result)) return result.then((value) => {
-								captureResult(info, started, args, void 0);
-								return value;
-							}, (error) => {
-								captureResult(info, started, args, error);
-								throw error;
-							});
-							captureResult(info, started, args, void 0);
-							return result;
-						} catch (error) {
-							captureResult(info, started, args, error);
-							throw error;
-						}
-					};
-					disposers.push(() => {
-						target.client[method] = originalMethod;
-					});
-				}
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const dispose of disposers) dispose();
-			};
-		}
-	};
-}
 //#endregion
 //#region src/serverless-integration.ts
 const defaultRandom = () => Math.random();
@@ -1676,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;
@@ -1711,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 {
@@ -1724,7 +2289,31 @@ 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;
 exports.captureProcessIntegration = captureProcessIntegration;
 exports.createAsyncLocalStorageContextManager = createAsyncLocalStorageContextManager;
@@ -1734,12 +2323,19 @@ exports.expressIntegration = expressIntegration;
 exports.fastifyIntegration = fastifyIntegration;
 exports.fileTransport = fileTransport;
 exports.formatSyslogMessage = formatSyslogMessage;
+exports.hapiIntegration = hapiIntegration;
 exports.installAsyncLocalStorageContext = installAsyncLocalStorageContext;
+exports.installLoggerDiagnosticsChannel = installLoggerDiagnosticsChannel;
+exports.koaIntegration = koaIntegration;
+exports.nestMiddlewareIntegration = nestMiddlewareIntegration;
+exports.nodeCompressionPayloadTransform = nodeCompressionPayloadTransform;
 exports.nodeFetchIntegration = nodeFetchIntegration;
 exports.nodeHttpClientIntegration = nodeHttpClientIntegration;
 exports.nodeHttpTransport = nodeHttpTransport;
 exports.nodeSyslogTransport = nodeSyslogTransport;
+exports.prismaIntegration = prismaIntegration;
 exports.queueIntegration = queueIntegration;
+exports.redisIntegration = redisIntegration;
 exports.rotatingFileTransport = rotatingFileTransport;
 exports.serverlessIntegration = serverlessIntegration;
 exports.stderrTransport = stderrTransport;