@loggerjs/node 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1757 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _loggerjs_core = require("@loggerjs/core");
+let fs = require("fs");
+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
+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";
+	const waiters = [];
+	let pendingWrites = 0;
+	let pendingDrains = 0;
+	let lastError;
+	let lastContext;
+	const reportInternalError = (error, operation) => {
+		lastContext?.reportInternalError(error, {
+			phase: "transport",
+			transport: transportName,
+			operation
+		});
+	};
+	const settleWaitersIfIdle = () => {
+		if (pendingWrites + pendingDrains > 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) => {
+		lastError = normalizeError(error);
+		reportInternalError(lastError, operation);
+	};
+	const waitForDrain = () => {
+		if (!stream.once) return;
+		pendingDrains += 1;
+		stream.once("drain", () => {
+			pendingDrains -= 1;
+			settleWaitersIfIdle();
+		});
+	};
+	const writePayload = (payload) => {
+		pendingWrites += 1;
+		try {
+			if (stream.write(payload, (error) => {
+				pendingWrites -= 1;
+				if (error) recordError(error, "write");
+				settleWaitersIfIdle();
+			}) === false) waitForDrain();
+		} catch (error) {
+			pendingWrites -= 1;
+			recordError(error, "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;
+			lastContext = context;
+			writePayload(codec.encode(event));
+		},
+		flush() {
+			if (pendingWrites + pendingDrains === 0) {
+				const error = lastError;
+				lastError = void 0;
+				if (error) return Promise.reject(error);
+				return Promise.resolve();
+			}
+			return new Promise((resolve, reject) => {
+				waiters.push({
+					resolve,
+					reject
+				});
+			});
+		}
+	};
+}
+function stderrTransport(options = {}) {
+	return stdoutTransport({
+		...options,
+		name: options.name ?? "stderr",
+		stream: process.stderr
+	});
+}
+//#endregion
+//#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;
+	};
+	return {
+		name: options.name ?? "file",
+		minLevel: options.minLevel,
+		stream,
+		log(event) {
+			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);
+		},
+		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();
+				});
+			});
+		}
+	};
+}
+//#endregion
+//#region src/rotating-file-transport.ts
+const textEncoder = new TextEncoder();
+function payloadBytes(payload) {
+	return typeof payload === "string" ? textEncoder.encode(payload).byteLength : payload.byteLength;
+}
+function normalizePositiveInteger(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return fallback;
+	return Math.floor(value);
+}
+function normalizeNonNegativeInteger(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value) || value < 0) return fallback;
+	return Math.floor(value);
+}
+function defaultArchivePath(path, index) {
+	return `${path}.${index}`;
+}
+function fileSize(path) {
+	try {
+		return (0, fs.statSync)(path).size;
+	} catch {
+		return 0;
+	}
+}
+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;
+	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();
+		if (maxFiles === 0) {
+			if ((0, fs.existsSync)(options.path)) (0, fs.unlinkSync)(options.path);
+			bytes = 0;
+			return;
+		}
+		const oldest = archivePath(options.path, maxFiles);
+		if ((0, fs.existsSync)(oldest)) (0, fs.unlinkSync)(oldest);
+		for (let index = maxFiles - 1; index >= 1; index -= 1) {
+			const source = archivePath(options.path, index);
+			if ((0, fs.existsSync)(source)) (0, fs.renameSync)(source, archivePath(options.path, index + 1));
+		}
+		if ((0, fs.existsSync)(options.path)) (0, fs.renameSync)(options.path, archivePath(options.path, 1));
+		bytes = 0;
+	};
+	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);
+		bytes += size;
+	};
+	return {
+		name: options.name ?? "rotating-file",
+		minLevel: options.minLevel,
+		log(event) {
+			if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) return;
+			writePayload(codec.encode(event));
+		},
+		logBatch(events) {
+			for (const event of events) {
+				if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) continue;
+				writePayload(codec.encode(event));
+			}
+		},
+		flush() {
+			return Promise.resolve();
+		},
+		flushSync() {},
+		close() {
+			closeFd();
+			return Promise.resolve();
+		},
+		rotate,
+		currentBytes: () => bytes
+	};
+}
+//#endregion
+//#region src/http-transport.ts
+function payloadToBody(payload) {
+	if (typeof payload === "string") return payload;
+	return Uint8Array.from(payload);
+}
+function nodeHttpTransport(options) {
+	const codec = options.codec ?? (0, _loggerjs_core.safeJsonCodec)();
+	const fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
+	return (0, _loggerjs_core.batchTransport)({
+		name: options.name ?? "node-http-inner",
+		minLevel: options.minLevel,
+		async logBatch(events) {
+			if (!fetchFn) throw new Error("fetch is not available. Use Node.js 18+ or pass fetchFn.");
+			const response = await fetchFn(options.url, {
+				method: options.method ?? "POST",
+				headers: {
+					"content-type": codec.contentType,
+					...options.headers
+				},
+				body: payloadToBody(codec.encode(events))
+			});
+			if (!response.ok) throw new Error(`nodeHttpTransport failed with status ${response.status}`);
+		}
+	}, {
+		name: options.name ?? "node-http",
+		maxRecords: options.maxRecords,
+		maxBatchSize: options.maxBatchSize,
+		maxBytes: options.maxBytes,
+		maxWaitMs: options.maxWaitMs,
+		flushIntervalMs: options.flushIntervalMs,
+		concurrency: options.concurrency,
+		maxQueueSize: options.maxQueueSize,
+		dropPolicy: options.dropPolicy,
+		estimateEventBytes: options.estimateEventBytes,
+		maxRetries: options.maxRetries,
+		retryBaseDelayMs: options.retryBaseDelayMs,
+		retryMaxDelayMs: options.retryMaxDelayMs,
+		random: options.random,
+		circuitBreakerFailureThreshold: options.circuitBreakerFailureThreshold,
+		circuitBreakerResetMs: options.circuitBreakerResetMs,
+		onDrop: options.onDrop
+	});
+}
+//#endregion
+//#region src/syslog-transport.ts
+const severityByLevel = {
+	trace: 7,
+	debug: 7,
+	info: 6,
+	warn: 4,
+	error: 3,
+	fatal: 2
+};
+function defaultUdpSocketFactory(protocol) {
+	return (0, dgram.createSocket)(protocol);
+}
+function defaultTcpSocketFactory(options) {
+	return (0, net.createConnection)(options);
+}
+function headerValue$4(value, fallback, maxLength) {
+	const text = String(value ?? fallback).trim().replace(/\s+/g, "_");
+	if (!text) return fallback;
+	return text.length > maxLength ? text.slice(0, maxLength) : text;
+}
+function timestamp(time) {
+	const value = new Date(time).toISOString();
+	return value === "Invalid Date" ? "-" : value;
+}
+function valueFor(value, event, fallback) {
+	return typeof value === "function" ? value(event) : value ?? fallback;
+}
+function defaultMessage(event) {
+	const extra = {};
+	if (event.data !== void 0) extra.data = event.data;
+	if (event.context !== void 0) extra.context = event.context;
+	if (event.error !== void 0) extra.error = event.error;
+	if (Object.keys(extra).length === 0) return event.message;
+	return `${event.message} ${(0, _loggerjs_core.safeJsonStringify)(extra)}`;
+}
+function formatSyslogMessage(event, options = {}) {
+	const facility = Math.max(0, Math.min(23, Math.trunc(options.facility ?? 1)));
+	const severity = severityByLevel[event.levelName] ?? 6;
+	const priority = facility * 8 + severity;
+	const host = headerValue$4(options.hostname, (0, os.hostname)(), 255);
+	const appName = headerValue$4(valueFor(options.appName, event, event.logger), "-", 48);
+	const procId = headerValue$4(valueFor(options.procId, event, "-"), "-", 128);
+	const msgId = headerValue$4(valueFor(options.msgId, event, event.type ?? event.levelName), "-", 32);
+	const structuredData = valueFor(options.structuredData, event, "-") || "-";
+	const message = options.formatMessage ? options.formatMessage(event) : defaultMessage(event);
+	return `<${priority}>1 ${timestamp(event.time)} ${host} ${appName} ${procId} ${msgId} ${structuredData} ${message}`;
+}
+function nodeSyslogTransport(options = {}) {
+	const protocol = options.protocol ?? "udp4";
+	const host = options.host ?? "127.0.0.1";
+	const port = options.port ?? 514;
+	const transportName = options.name ?? "syslog";
+	const unref = options.unref ?? true;
+	const tcpFraming = options.tcpFraming ?? "newline";
+	const udpSocketFactory = options.udpSocketFactory ?? defaultUdpSocketFactory;
+	const tcpSocketFactory = options.tcpSocketFactory ?? defaultTcpSocketFactory;
+	let udpSocket;
+	let tcpSocket;
+	let lastContext;
+	const reportError = (error, context, operation) => {
+		try {
+			options.onError?.(error, { operation });
+		} catch (onErrorError) {
+			context?.reportInternalError(onErrorError, {
+				operation: "on-error",
+				phase: "transport",
+				transport: transportName
+			});
+		}
+		context?.reportInternalError(error, {
+			operation,
+			phase: "transport",
+			transport: transportName
+		});
+	};
+	const getUdpSocket = (context) => {
+		if (udpSocket) return udpSocket;
+		const socket = udpSocketFactory(protocol === "udp6" ? "udp6" : "udp4");
+		socket.on?.("error", (error) => reportError(error, lastContext ?? context, "socket-error"));
+		if (unref) socket.unref?.();
+		udpSocket = socket;
+		return socket;
+	};
+	const getTcpSocket = (context) => {
+		if (tcpSocket) return tcpSocket;
+		const socket = tcpSocketFactory({
+			host,
+			port
+		});
+		socket.on?.("error", (error) => reportError(error, lastContext ?? context, "socket-error"));
+		if (unref) socket.unref?.();
+		tcpSocket = socket;
+		return socket;
+	};
+	const send = (message, context) => {
+		lastContext = context;
+		if (protocol === "tcp") {
+			const bytes = new TextEncoder().encode(message).byteLength;
+			const payload = tcpFraming === "octet-counting" ? `${bytes} ${message}` : `${message}\n`;
+			getTcpSocket(context).write(payload, (error) => {
+				if (error) reportError(error, context, "send");
+			});
+			return;
+		}
+		getUdpSocket(context).send(message, port, host, (error) => {
+			if (error) reportError(error, context, "send");
+		});
+	};
+	return {
+		name: transportName,
+		minLevel: options.minLevel,
+		log(event, context) {
+			send(formatSyslogMessage(event, options), context);
+		},
+		logBatch(events, context) {
+			for (const event of events) send(formatSyslogMessage(event, options), context);
+		},
+		async close() {
+			udpSocket?.close?.();
+			udpSocket = void 0;
+			tcpSocket?.end?.();
+			tcpSocket = void 0;
+		}
+	};
+}
+//#endregion
+//#region src/worker-transport.ts
+function createDefaultWorker(options) {
+	if (!options.workerScript) throw new Error("workerTransport requires worker, workerFactory, or workerScript.");
+	return new node_worker_threads.Worker(options.workerScript, options.workerOptions);
+}
+function payloadToBytes(payload) {
+	if (typeof payload !== "string") return payload;
+	return new TextEncoder().encode(payload);
+}
+function transferablePayload(payload) {
+	const copy = Uint8Array.from(payload);
+	return {
+		payload: copy,
+		transferList: [copy.buffer]
+	};
+}
+function workerTransport(options = {}) {
+	const codec = options.codec ?? (0, _loggerjs_core.safeJsonCodec)();
+	const transportName = options.name ?? "worker";
+	const fallback = options.fallback;
+	let worker;
+	let failed = false;
+	let lastContext;
+	const reportInternalError = (error, operation) => {
+		lastContext?.reportInternalError(error, {
+			phase: "transport",
+			transport: transportName,
+			operation
+		});
+	};
+	const markFailed = (error, operation) => {
+		failed = true;
+		(0, _loggerjs_core.incrementLoggerMetaCounter)("transport.worker.failed");
+		reportInternalError(error, operation);
+	};
+	const onWorkerError = (error) => markFailed(error, "worker-error");
+	const onWorkerExit = (code) => {
+		if (typeof code === "number" && code !== 0) markFailed(code, "worker-exit");
+	};
+	const getWorker = () => {
+		if (failed) return void 0;
+		if (worker) return worker;
+		try {
+			worker = options.worker ?? options.workerFactory?.() ?? createDefaultWorker(options);
+			worker.on?.("error", onWorkerError);
+			worker.on?.("exit", onWorkerExit);
+			return worker;
+		} catch (error) {
+			markFailed(error, "create-worker");
+			return;
+		}
+	};
+	const fallbackBatch = async (events, context) => {
+		if (fallback?.logBatch) {
+			await fallback.logBatch(events, context);
+			return;
+		}
+		if (fallback?.log) for (const event of events) await fallback.log(event, context);
+	};
+	const postBatch = async (events, context) => {
+		lastContext = context;
+		const currentWorker = getWorker();
+		if (!currentWorker) {
+			await fallbackBatch(events, context);
+			return;
+		}
+		const encoded = payloadToBytes(codec.encode(events));
+		const transferable = options.transferBuffers === false ? {
+			payload: encoded,
+			transferList: void 0
+		} : transferablePayload(encoded);
+		const message = {
+			type: "loggerjs:batch",
+			codec: codec.name,
+			contentType: codec.contentType,
+			count: events.length,
+			payload: transferable.payload
+		};
+		try {
+			currentWorker.postMessage(message, transferable.transferList);
+		} catch (error) {
+			markFailed(error, "post-message");
+			await fallbackBatch(events, context);
+		}
+	};
+	return {
+		name: transportName,
+		minLevel: options.minLevel,
+		log(event, context) {
+			if (options.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(options.minLevel)) return;
+			return postBatch([event], context);
+		},
+		logBatch(events, context) {
+			return postBatch(events, context);
+		},
+		async flush() {
+			await fallback?.flush?.();
+		},
+		async close() {
+			worker?.off?.("error", onWorkerError);
+			worker?.off?.("exit", onWorkerExit);
+			await fallback?.close?.();
+			await worker?.terminate?.();
+		}
+	};
+}
+//#endregion
+//#region src/context.ts
+function mergeContext(...items) {
+	const out = {};
+	for (const item of items) {
+		if (!item) continue;
+		Object.assign(out, item);
+	}
+	return (0, _loggerjs_core.createBoundContext)(out) ?? void 0;
+}
+function createAsyncLocalStorageContextManager(storage = new node_async_hooks.AsyncLocalStorage()) {
+	return {
+		get() {
+			return storage.getStore();
+		},
+		with(context, fn) {
+			return storage.run(mergeContext(storage.getStore(), context) ?? Object.freeze({}), fn);
+		},
+		disable() {
+			storage.disable();
+		}
+	};
+}
+function installAsyncLocalStorageContext(manager = createAsyncLocalStorageContextManager()) {
+	(0, _loggerjs_core.setContextManager)(manager);
+	return () => {
+		(0, _loggerjs_core.resetContextManager)();
+		manager.disable();
+	};
+}
+//#endregion
+//#region src/cli-integration.ts
+const defaultSignals = ["SIGINT", "SIGTERM"];
+function defaultProcess() {
+	return globalThis.process;
+}
+function defaultSanitizeArg(arg) {
+	if (/^(--?[^=\s]*(token|password|passwd|secret|key)[^=\s]*=)/i.test(arg)) return arg.replace(/=.*/, "=[redacted]");
+	return arg;
+}
+function defaultCommand(argv) {
+	return argv[1] ?? argv[0];
+}
+function levelFor(level, event, code) {
+	if (typeof level === "function") return level(event, code);
+	if (level) return level;
+	if (event === "signal") return "warn";
+	if (event === "exit" && Number(code ?? 0) !== 0) return "error";
+	return "info";
+}
+function pickEnv(env, names) {
+	if (!env || !names || names.length === 0) return void 0;
+	const out = {};
+	for (const name of names) {
+		const value = env[name];
+		if (value !== void 0) out[name] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function removeListener$1(processLike, event, listener) {
+	if (processLike.off) {
+		processLike.off(event, listener);
+		return;
+	}
+	processLike.removeListener?.(event, listener);
+}
+function captureCliIntegration(options = {}) {
+	const name = options.name ?? "cli";
+	const captureStart = options.captureStart ?? true;
+	const captureExit = options.captureExit ?? true;
+	const captureSignals = options.captureSignals ?? true;
+	const captureCwd = options.captureCwd ?? true;
+	const signals = options.signals ?? defaultSignals;
+	const sanitizeArg = options.sanitizeArg ?? defaultSanitizeArg;
+	const commandFor = options.getCommand ?? defaultCommand;
+	return {
+		name: "capture-cli",
+		setup(api) {
+			const processLike = options.process ?? defaultProcess();
+			if (!processLike) return;
+			const argv = processLike.argv ?? [];
+			const command = commandFor(argv);
+			const sanitizedArgv = argv.map((arg, index) => sanitizeArg(arg, index, argv));
+			const disposers = [];
+			let disposed = false;
+			const capture = api.guard((input) => {
+				if (!disposed) api.capture(input);
+			});
+			const cliBase = {
+				kind: name,
+				command,
+				argv: sanitizedArgv,
+				cwd: captureCwd ? processLike.cwd?.() : void 0,
+				env: pickEnv(processLike.env, options.captureEnv)
+			};
+			if (captureStart) capture({
+				level: levelFor(options.level, "start"),
+				message: `CLI start${command ? ` ${command}` : ""}`,
+				props: { cli: {
+					...cliBase,
+					lifecycle: "start"
+				} }
+			});
+			if (captureExit && processLike.on) {
+				const onExit = (code) => {
+					const exitCode = code ?? processLike.exitCode ?? 0;
+					capture({
+						level: levelFor(options.level, "exit", exitCode),
+						message: `CLI exit ${String(exitCode)}`,
+						props: { cli: {
+							...cliBase,
+							lifecycle: "exit",
+							exitCode
+						} }
+					});
+				};
+				processLike.on("exit", onExit);
+				disposers.push(() => removeListener$1(processLike, "exit", onExit));
+			}
+			if (captureSignals && processLike.on) for (const signal of signals) {
+				const onSignal = () => {
+					capture({
+						level: levelFor(options.level, "signal", signal),
+						message: `CLI signal ${signal}`,
+						props: { cli: {
+							...cliBase,
+							lifecycle: "signal",
+							signal
+						} }
+					});
+				};
+				processLike.on(signal, onSignal);
+				disposers.push(() => removeListener$1(processLike, signal, onSignal));
+			}
+			return () => {
+				if (disposed) return;
+				disposed = true;
+				for (const dispose of disposers) dispose();
+			};
+		}
+	};
+}
+//#endregion
+//#region src/database-integration.ts
+const defaultMethods$1 = [
+	"query",
+	"execute",
+	"run",
+	"all",
+	"get"
+];
+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 defaultStatement(args) {
+	const first = args[0];
+	if (typeof first === "string") return first;
+	if (typeof first !== "object" || first === null) return void 0;
+	const input = first;
+	if (typeof input.sql === "string") return input.sql;
+	if (typeof input.text === "string") return input.text;
+	if (typeof input.query === "string") return input.query;
+}
+function statementFor(args, method, options) {
+	const statement = options.getStatement?.(args, method) ?? defaultStatement(args);
+	return statement && options.sanitizeStatement ? options.sanitizeStatement(statement) : statement;
+}
+function parametersFor(args, captureParameters) {
+	if (!captureParameters) return void 0;
+	const first = args[0];
+	const parameters = args[1] ?? (typeof first === "object" && first ? first.values ?? first.params ?? first.parameters : void 0);
+	return parameters === void 0 ? void 0 : (0, _loggerjs_core.normalizeValue)(parameters, {
+		maxDepth: 4,
+		maxObjectKeys: 80
+	});
+}
+function databaseIntegration(options = {}) {
+	const targets = options.targets ?? (options.client ? [{
+		client: options.client,
+		name: options.name,
+		system: options.system,
+		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: "database",
+		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 ? `Database error ${info.method}${info.statement ? ` ${info.statement}` : ""}` : `Database ${info.method}${info.statement ? ` ${info.statement}` : ""}`,
+					error,
+					props: { db: {
+						kind: info.target,
+						system: info.system,
+						method: info.method,
+						statement: info.statement,
+						durationMs,
+						parameters: parametersFor(args, options.captureParameters ?? false)
+					} }
+				});
+			};
+			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 ?? "database";
+					const system = target.system ?? options.system;
+					target.client[method] = function wrappedDatabaseMethod(...args) {
+						const started = Date.now();
+						const info = {
+							target: targetName,
+							system,
+							method,
+							statement: statementFor(args, method, options)
+						};
+						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/express-integration.ts
+const defaultRandom$5 = () => 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) {
+	if (aborted) return "warn";
+	if (status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function requestUrl(req) {
+	return req.originalUrl ?? req.url ?? req.path ?? "/";
+}
+function headerValue$3(value) {
+	if (typeof value === "number") return String(value);
+	return value;
+}
+function pickRequestHeaders$1(req, names) {
+	if (!names || names.length === 0 || !req.headers) return void 0;
+	const out = {};
+	for (const name of names) {
+		const value = req.headers[name.toLowerCase()] ?? req.headers[name];
+		if (value !== void 0) out[name.toLowerCase()] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function pickResponseHeaders$1(res, names) {
+	if (!names || names.length === 0 || !res.getHeader) return void 0;
+	const out = {};
+	for (const name of names) {
+		const value = headerValue$3(res.getHeader(name));
+		if (value !== void 0) out[name.toLowerCase()] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function defaultRoute$1(req) {
+	const path = req.route?.path;
+	return typeof path === "string" ? path : void 0;
+}
+function removeListener(res, event, listener) {
+	if (res.off) {
+		res.off(event, listener);
+		return;
+	}
+	res.removeListener?.(event, listener);
+}
+function onResponseDone(res, event, listener) {
+	if (res.once) {
+		res.once(event, listener);
+		return;
+	}
+	res.on?.(event, listener);
+}
+function expressIntegration(logger, options = {}) {
+	const name = options.name ?? "express";
+	const minStatus = options.minStatus ?? 400;
+	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
+	const captureAborted = options.captureAborted ?? true;
+	const sampleRate = options.sampleRate ?? 1;
+	const random = options.random ?? defaultRandom$5;
+	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl$3;
+	const levelFor = options.level ?? defaultLevel$5;
+	const routeFor = options.getRoute ?? defaultRoute$1;
+	const bindContext = options.bindContext ?? true;
+	return (req, res, next) => {
+		const started = Date.now();
+		const method = (req.method ?? "GET").toUpperCase();
+		const url = sanitizeUrl(requestUrl(req));
+		const requestId = options.getRequestId?.(req, res);
+		let completed = false;
+		const context = {
+			httpMethod: method,
+			httpUrl: url,
+			requestId,
+			...options.context?.(req, res)
+		};
+		const shouldCapture = (status, aborted) => {
+			if (aborted && captureAborted) return true;
+			if (status >= minStatus) return true;
+			if (!captureAll) return false;
+			return sampleRate >= 1 || random() < sampleRate;
+		};
+		const cleanup = () => {
+			removeListener(res, "finish", onFinish);
+			removeListener(res, "close", onClose);
+		};
+		const logRequest = (event) => {
+			if (completed) return;
+			completed = true;
+			cleanup();
+			const status = res.statusCode ?? 0;
+			const aborted = event === "close" && res.writableEnded !== true;
+			if (!shouldCapture(status, aborted)) return;
+			const http = {
+				kind: name,
+				framework: "express",
+				method,
+				url,
+				route: routeFor(req),
+				status,
+				durationMs: Date.now() - started,
+				aborted,
+				requestId,
+				remoteAddress: req.ip ?? req.socket?.remoteAddress,
+				requestHeaders: pickRequestHeaders$1(req, options.captureRequestHeaders),
+				responseHeaders: pickResponseHeaders$1(res, options.captureResponseHeaders)
+			};
+			logger.log(levelFor(status, req, res, aborted), `Express ${status} ${method} ${url}`, { http });
+		};
+		const onFinish = () => logRequest("finish");
+		const onClose = () => logRequest("close");
+		onResponseDone(res, "finish", onFinish);
+		onResponseDone(res, "close", onClose);
+		if (bindContext) {
+			(0, _loggerjs_core.withContext)(context, () => next());
+			return;
+		}
+		next();
+	};
+}
+//#endregion
+//#region src/fastify-integration.ts
+const defaultRandom$4 = () => 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) {
+	if (error || status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function headerValue$2(value) {
+	if (typeof value === "number") return String(value);
+	return value;
+}
+function pickRequestHeaders(request, names) {
+	if (!names || names.length === 0 || !request.headers) return void 0;
+	const out = {};
+	for (const name of names) {
+		const value = request.headers[name.toLowerCase()] ?? request.headers[name];
+		if (value !== void 0) out[name.toLowerCase()] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function pickResponseHeaders(reply, names) {
+	if (!names || names.length === 0 || !reply.getHeader) return void 0;
+	const out = {};
+	for (const name of names) {
+		const value = headerValue$2(reply.getHeader(name));
+		if (value !== void 0) out[name.toLowerCase()] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function defaultRoute(request) {
+	return request.routeOptions?.url ?? request.routerPath;
+}
+function fastifyIntegration(logger, options = {}) {
+	const name = options.name ?? "fastify";
+	const minStatus = options.minStatus ?? 400;
+	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
+	const sampleRate = options.sampleRate ?? 1;
+	const random = options.random ?? defaultRandom$4;
+	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl$2;
+	const levelFor = options.level ?? defaultLevel$4;
+	const routeFor = options.getRoute ?? defaultRoute;
+	const bindContext = options.bindContext ?? true;
+	const states = /* @__PURE__ */ new WeakMap();
+	const shouldCapture = (status, error) => {
+		if (error) return true;
+		if (status >= minStatus) return true;
+		if (!captureAll) return false;
+		return sampleRate >= 1 || random() < sampleRate;
+	};
+	return (instance, _pluginOptions, done) => {
+		instance.addHook("onRequest", (request, reply, next) => {
+			const method = (request.method ?? "GET").toUpperCase();
+			const url = sanitizeUrl(request.url ?? "/");
+			const requestId = options.getRequestId?.(request, reply) ?? request.id;
+			states.set(request, { started: Date.now() });
+			const context = {
+				httpMethod: method,
+				httpUrl: url,
+				requestId,
+				...options.context?.(request, reply)
+			};
+			if (bindContext) {
+				(0, _loggerjs_core.withContext)(context, () => next());
+				return;
+			}
+			next();
+		});
+		instance.addHook("onError", (request, _reply, error, next) => {
+			const state = states.get(request);
+			if (state) state.error = error;
+			else states.set(request, {
+				started: Date.now(),
+				error
+			});
+			next();
+		});
+		instance.addHook("onResponse", (request, reply, next) => {
+			const state = states.get(request) ?? { started: Date.now() };
+			states.delete(request);
+			const status = reply.statusCode ?? 0;
+			const error = state.error;
+			if (!shouldCapture(status, error)) {
+				next();
+				return;
+			}
+			const method = (request.method ?? "GET").toUpperCase();
+			const url = sanitizeUrl(request.url ?? "/");
+			const requestId = options.getRequestId?.(request, reply) ?? request.id;
+			const data = { http: {
+				kind: name,
+				framework: "fastify",
+				method,
+				url,
+				route: routeFor(request),
+				status,
+				durationMs: Date.now() - state.started,
+				requestId,
+				remoteAddress: request.ip,
+				requestHeaders: pickRequestHeaders(request, options.captureRequestHeaders),
+				responseHeaders: pickResponseHeaders(reply, options.captureResponseHeaders)
+			} };
+			if (error) data.error = error;
+			logger.log(levelFor(status, request, reply, error), `Fastify ${status} ${method} ${url}`, { ...data });
+			next();
+		});
+		done?.();
+	};
+}
+//#endregion
+//#region src/node-fetch-integration.ts
+const defaultRandom$3 = () => 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) {
+	if (error || status === void 0 || status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function isUrlLike$1(value) {
+	return typeof URL !== "undefined" && value instanceof URL;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function headerValue$1(headers, name) {
+	if (!isObject(headers)) return void 0;
+	if (typeof headers.get === "function") return headers.get?.(name) ?? void 0;
+	const value = headers[name.toLowerCase()] ?? headers[name];
+	return value === void 0 ? void 0 : String(value);
+}
+function pickHeaders$1(headers, names) {
+	if (!names || names.length === 0) return void 0;
+	const out = {};
+	for (const name of names) {
+		const lowerName = name.toLowerCase();
+		const value = headerValue$1(headers, lowerName) ?? headerValue$1(headers, name);
+		if (value !== void 0) out[lowerName] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function requestInfo$1(input, init, sanitizeUrl, captureRequestHeaders) {
+	const request = isObject(input) && !isUrlLike$1(input) ? input : void 0;
+	return {
+		method: (init?.method ?? request?.method ?? "GET").toUpperCase(),
+		url: sanitizeUrl(isUrlLike$1(input) ? input.href : typeof input === "string" ? input : request?.url ?? "/"),
+		requestHeaders: pickHeaders$1(init?.headers ?? request?.headers, captureRequestHeaders)
+	};
+}
+function statusMessage$1(status) {
+	return status === void 0 ? "unknown" : String(status);
+}
+function nodeFetchIntegration(options = {}) {
+	const name = options.name ?? "node-fetch";
+	const minStatus = options.minStatus ?? 400;
+	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
+	const sampleRate = options.sampleRate ?? 1;
+	const random = options.random ?? defaultRandom$3;
+	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl$1;
+	const levelFor = options.level ?? defaultLevel$3;
+	const shouldCapture = (status, error) => {
+		if (error) return true;
+		if (status !== void 0 && status >= minStatus) return true;
+		if (!captureAll) return false;
+		return sampleRate >= 1 || random() < sampleRate;
+	};
+	return {
+		name: "node-fetch",
+		setup(api) {
+			const target = options.target ?? globalThis;
+			if (!target.fetch) return;
+			const originalFetch = target.fetch;
+			const capture = api.guard((input) => api.capture(input));
+			let disposed = false;
+			const captureResult = (info, durationMs, status, error, responseHeaders) => {
+				if (disposed || !shouldCapture(status, error)) return;
+				capture({
+					level: levelFor(status, error, info),
+					message: error ? `Fetch error ${info.method} ${info.url}` : `Fetch ${statusMessage$1(status)} ${info.method} ${info.url}`,
+					error,
+					props: { http: {
+						kind: name,
+						runtime: "node",
+						instrument: "fetch",
+						direction: "outgoing",
+						method: info.method,
+						url: info.url,
+						status,
+						durationMs,
+						requestHeaders: info.requestHeaders,
+						responseHeaders
+					} }
+				});
+			};
+			target.fetch = async function patchedFetch(input, init) {
+				const started = Date.now();
+				const info = requestInfo$1(input, init, sanitizeUrl, options.captureRequestHeaders);
+				try {
+					const response = await originalFetch.call(this, input, init);
+					captureResult(info, Date.now() - started, response.status, void 0, pickHeaders$1(response.headers, options.captureResponseHeaders));
+					return response;
+				} catch (error) {
+					captureResult(info, Date.now() - started, void 0, error);
+					throw error;
+				}
+			};
+			return () => {
+				if (disposed) return;
+				disposed = true;
+				target.fetch = originalFetch;
+			};
+		}
+	};
+}
+//#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();
+let cachedHttpModule;
+let cachedHttpsModule;
+function loadBuiltin(name, fallback) {
+	try {
+		return requireBuiltin$1(name);
+	} catch {
+		try {
+			return requireBuiltin$1(fallback);
+		} catch {
+			return null;
+		}
+	}
+}
+function loadHttpModule() {
+	if (cachedHttpModule !== void 0) return cachedHttpModule;
+	cachedHttpModule = loadBuiltin("node:http", "http");
+	return cachedHttpModule;
+}
+function loadHttpsModule() {
+	if (cachedHttpsModule !== void 0) return cachedHttpsModule;
+	cachedHttpsModule = loadBuiltin("node:https", "https");
+	return cachedHttpsModule;
+}
+function defaultSanitizeUrl(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$2(status, error) {
+	if (error || status === void 0 || status >= 500) return "error";
+	if (status >= 400) return "warn";
+	return "info";
+}
+function isUrlLike(value) {
+	return typeof URL !== "undefined" && value instanceof URL;
+}
+function isOptionsObject(value) {
+	return typeof value === "object" && value !== null && !isUrlLike(value);
+}
+function headerValue(value) {
+	if (value === void 0) return void 0;
+	if (Array.isArray(value)) return value.map(String);
+	return String(value);
+}
+function pickHeaders(headers, names) {
+	if (!names || names.length === 0 || !isOptionsObject(headers)) return void 0;
+	const out = {};
+	for (const name of names) {
+		const lowerName = name.toLowerCase();
+		const value = headerValue(headers[lowerName] ?? headers[name]);
+		if (value !== void 0) out[lowerName] = value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function maybeUrl(value) {
+	if (isUrlLike(value)) return value;
+	if (typeof value !== "string") return void 0;
+	try {
+		return new URL(value);
+	} catch {
+		return;
+	}
+}
+function pathFromUrl(url) {
+	if (!url) return "/";
+	return `${url.pathname || "/"}${url.search}`;
+}
+function optionString(options, key) {
+	const value = options[key];
+	if (value === void 0) return void 0;
+	return String(value);
+}
+function requestInfo(args, defaultProtocol, sanitizeUrl, captureRequestHeaders) {
+	const first = args[0];
+	const second = args[1];
+	const parsed = maybeUrl(first);
+	const options = isOptionsObject(first) ? first : isOptionsObject(second) ? second : void 0;
+	const protocol = optionString(options ?? {}, "protocol") ?? parsed?.protocol ?? defaultProtocol;
+	const method = (optionString(options ?? {}, "method") ?? "GET").toUpperCase();
+	const host = optionString(options ?? {}, "host") ?? optionString(options ?? {}, "hostname") ?? parsed?.host;
+	const port = optionString(options ?? {}, "port");
+	const path = optionString(options ?? {}, "path") ?? pathFromUrl(parsed);
+	const requestHeaders = pickHeaders(options?.headers, captureRequestHeaders);
+	return {
+		protocol,
+		method,
+		url: sanitizeUrl(parsed?.href ?? (host ? `${protocol}//${host}${port ? `:${port}` : ""}${path}` : path)),
+		requestHeaders
+	};
+}
+function listenOnce(request, event, listener) {
+	let active = true;
+	const wrapped = (...args) => {
+		if (!active) return;
+		active = false;
+		cleanup();
+		listener(...args);
+	};
+	const cleanup = () => {
+		request.off?.(event, wrapped);
+		request.removeListener?.(event, wrapped);
+	};
+	if (request.once) request.once(event, wrapped);
+	else request.on?.(event, wrapped);
+}
+function statusMessage(status) {
+	return status === void 0 ? "unknown" : String(status);
+}
+function nodeHttpClientIntegration(options = {}) {
+	const name = options.name ?? "node-http-client";
+	const minStatus = options.minStatus ?? 400;
+	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
+	const sampleRate = options.sampleRate ?? 1;
+	const random = options.random ?? defaultRandom$2;
+	const sanitizeUrl = options.sanitizeUrl ?? defaultSanitizeUrl;
+	const levelFor = options.level ?? defaultLevel$2;
+	const shouldCapture = (status, error) => {
+		if (error) return true;
+		if (status !== void 0 && status >= minStatus) return true;
+		if (!captureAll) return false;
+		return sampleRate >= 1 || random() < sampleRate;
+	};
+	return {
+		name: "node-http-client",
+		setup(api) {
+			const httpModule = options.httpModule === void 0 ? loadHttpModule() : options.httpModule;
+			const httpsModule = options.httpsModule === void 0 ? loadHttpsModule() : options.httpsModule;
+			const capture = api.guard((input) => api.capture(input));
+			const disposers = [];
+			let disposed = false;
+			const captureResult = (info, status, error, responseHeaders) => {
+				if (disposed || !shouldCapture(status, error)) return;
+				capture({
+					level: levelFor(status, error, info),
+					message: error ? `HTTP error ${info.method} ${info.url}` : `HTTP ${statusMessage(status)} ${info.method} ${info.url}`,
+					error,
+					props: { http: {
+						kind: name,
+						runtime: "node",
+						direction: "outgoing",
+						protocol: info.protocol,
+						method: info.method,
+						url: info.url,
+						status,
+						requestHeaders: info.requestHeaders,
+						responseHeaders
+					} }
+				});
+			};
+			const patchModule = (module, defaultProtocol) => {
+				if (!module?.request) return;
+				const originalRequest = module.request;
+				const originalGet = module.get;
+				module.request = function patchedRequest(...args) {
+					const info = requestInfo(args, defaultProtocol, sanitizeUrl, options.captureRequestHeaders);
+					const request = originalRequest.apply(this, args);
+					listenOnce(request, "response", (message) => {
+						const response = message;
+						captureResult(info, response.statusCode, void 0, pickHeaders(response.headers, options.captureResponseHeaders));
+					});
+					listenOnce(request, "error", (error) => captureResult(info, void 0, error));
+					return request;
+				};
+				if (originalGet) module.get = function patchedGet(...args) {
+					const request = module.request?.apply(this, args) ?? originalGet.apply(this, args);
+					request.end?.();
+					return request;
+				};
+				disposers.push(() => {
+					module.request = originalRequest;
+					if (originalGet) module.get = originalGet;
+				});
+			};
+			patchModule(httpModule, "http:");
+			patchModule(httpsModule, "https:");
+			return () => {
+				if (disposed) return;
+				disposed = true;
+				for (const dispose of disposers) dispose();
+			};
+		}
+	};
+}
+//#endregion
+//#region src/process-integration.ts
+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 exitOnUncaught = options.exitOnUncaught ?? true;
+	const flushTimeoutMs = options.flushTimeoutMs ?? 250;
+	const exitFn = options.exitFn ?? ((code) => process.exit(code));
+	return {
+		name: "capture-process",
+		setup(api) {
+			const disposers = [];
+			let disposed = false;
+			const capture = api.guard((input) => api.capture(input));
+			const flushSync = () => {
+				try {
+					api.flushSync?.();
+				} catch {}
+			};
+			const flushBounded = async () => {
+				let timer;
+				try {
+					await Promise.race([api.flush(), new Promise((resolve) => {
+						timer = setTimeout(resolve, flushTimeoutMs);
+					})]);
+				} catch {} finally {
+					if (timer) clearTimeout(timer);
+				}
+			};
+			const flushBestEffort = () => {
+				flushSync();
+				flushBounded();
+			};
+			if (uncaughtException) {
+				const onUncaughtException = (error) => {
+					capture({
+						level: "fatal",
+						message: error.message,
+						error,
+						props: { process: { kind: "uncaughtException" } }
+					});
+					flushSync();
+					const flushed = flushBounded();
+					if (exitOnUncaught) flushed.finally(() => exitFn(1));
+				};
+				process.on("uncaughtException", onUncaughtException);
+				disposers.push(() => process.off("uncaughtException", onUncaughtException));
+			}
+			if (unhandledRejection) {
+				const onUnhandledRejection = (reason) => {
+					capture({
+						level: "error",
+						message: reason instanceof Error ? reason.message : "Unhandled promise rejection",
+						error: reason,
+						props: {
+							process: { kind: "unhandledRejection" },
+							reason: (0, _loggerjs_core.normalizeValue)(reason, { maxDepth: 5 })
+						}
+					});
+					flushBestEffort();
+				};
+				process.on("unhandledRejection", onUnhandledRejection);
+				disposers.push(() => process.off("unhandledRejection", onUnhandledRejection));
+			}
+			if (warning) {
+				const onWarning = (warn) => {
+					capture({
+						level: "warn",
+						message: warn.message,
+						error: warn,
+						props: { process: {
+							kind: "warning",
+							name: warn.name,
+							code: warn.code
+						} }
+					});
+				};
+				process.on("warning", onWarning);
+				disposers.push(() => process.off("warning", onWarning));
+			}
+			if (beforeExitFlush) {
+				const onBeforeExit = () => {
+					flushBounded();
+				};
+				process.on("beforeExit", onBeforeExit);
+				disposers.push(() => process.off("beforeExit", onBeforeExit));
+			}
+			if (exitFlush) {
+				const onExit = () => {
+					flushSync();
+				};
+				process.on("exit", onExit);
+				disposers.push(() => process.off("exit", onExit));
+			}
+			return () => {
+				if (disposed) return;
+				disposed = true;
+				for (const dispose of disposers) dispose();
+			};
+		}
+	};
+}
+//#endregion
+//#region src/queue-integration.ts
+const defaultMethods = [
+	"add",
+	"ack",
+	"consume",
+	"dequeue",
+	"nack",
+	"process",
+	"publish",
+	"receive",
+	"send",
+	"sendToQueue"
+];
+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 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$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();
+let coldStart = true;
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function defaultLevel(error) {
+	return error ? "error" : "info";
+}
+function defaultRequestId(event, context) {
+	const ctx = context;
+	const evt = event;
+	return ctx?.awsRequestId ?? evt?.requestContext?.requestId ?? evt?.headers?.["x-request-id"] ?? evt?.headers?.["X-Request-Id"];
+}
+function defaultOperation(event, context) {
+	const ctx = context;
+	const evt = event;
+	return evt?.routeKey ?? evt?.requestContext?.routeKey ?? (evt?.requestContext?.http?.method && evt.requestContext.http.path ? `${evt.requestContext.http.method} ${evt.requestContext.http.path}` : void 0) ?? (evt?.httpMethod && (evt.rawPath ?? evt.path) ? `${evt.httpMethod} ${evt.rawPath ?? evt.path}` : void 0) ?? ctx?.functionName;
+}
+function normalizeUnknown(value) {
+	return (0, _loggerjs_core.normalizeValue)(value, {
+		maxDepth: 5,
+		maxObjectKeys: 120
+	});
+}
+function serverlessIntegration(logger, handler, options = {}) {
+	const name = options.name ?? "serverless";
+	const platform = options.platform ?? "serverless";
+	const captureSuccessful = options.captureSuccessful ?? options.captureAll ?? true;
+	const sampleRate = options.sampleRate ?? 1;
+	const random = options.random ?? defaultRandom;
+	const bindContext = options.bindContext ?? true;
+	const levelFor = options.level ?? defaultLevel;
+	return (event, context, callback) => {
+		const started = Date.now();
+		const currentColdStart = coldStart;
+		coldStart = false;
+		const requestId = options.getRequestId?.(event, context) ?? defaultRequestId(event, context);
+		const operation = options.getOperation?.(event, context) ?? defaultOperation(event, context);
+		let captured = false;
+		const shouldCapture = (error) => {
+			if (error) return true;
+			if (!captureSuccessful) return false;
+			return sampleRate >= 1 || random() < sampleRate;
+		};
+		const capture = (error, result) => {
+			if (captured || !shouldCapture(error)) return;
+			captured = true;
+			const durationMs = Date.now() - started;
+			const info = {
+				context,
+				event,
+				operation,
+				requestId
+			};
+			logger.log(levelFor(error, durationMs, info), `Serverless ${operation ?? name}`, {
+				error,
+				serverless: {
+					kind: name,
+					platform,
+					operation,
+					requestId,
+					coldStart: currentColdStart,
+					durationMs,
+					event: options.captureEvent ? options.normalizeEvent?.(event) ?? normalizeUnknown(event) : void 0,
+					result: options.captureResult && result !== void 0 ? options.normalizeResult?.(result) ?? normalizeUnknown(result) : void 0
+				}
+			});
+		};
+		const wrappedCallback = callback ? (error, result) => {
+			capture(error, result);
+			callback(error, result);
+		} : void 0;
+		const invoke = () => {
+			try {
+				const result = handler(event, context, wrappedCallback);
+				if (isPromiseLike(result)) return result.then((value) => {
+					capture(void 0, value);
+					return value;
+				}, (error) => {
+					capture(error);
+					throw error;
+				});
+				if (result !== void 0 || !wrappedCallback) capture(void 0, result);
+				return result;
+			} catch (error) {
+				capture(error);
+				throw error;
+			}
+		};
+		if (!bindContext) return invoke();
+		return (0, _loggerjs_core.withContext)({
+			functionName: context?.functionName,
+			requestId,
+			serverlessPlatform: platform
+		}, invoke);
+	};
+}
+//#endregion
+//#region src/diagnostics-channel-integration.ts
+const defaultChannels = [
+	"http.client.request.start",
+	"http.client.response.finish",
+	"http.server.request.start",
+	"http.server.response.finish",
+	"undici:request:create",
+	"undici:request:headers",
+	"undici:request:trailers",
+	"undici:request:error"
+];
+const requireBuiltin = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+let cachedDiagnosticsChannel;
+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;
+			if (!diagnosticsChannel) return;
+			const disposers = [];
+			let disposed = false;
+			const capture = api.guard((input) => api.capture(input));
+			for (const channel of channels) {
+				const listener = (message, name) => {
+					capture({
+						level: name.endsWith(":error") ? "error" : "debug",
+						message: `diagnostics_channel ${name}`,
+						props: { diagnostics: {
+							channel: name,
+							message: captureMessage ? (0, _loggerjs_core.normalizeValue)(message, { maxDepth: 4 }) : void 0
+						} }
+					});
+				};
+				diagnosticsChannel.subscribe(channel, listener);
+				disposers.push(() => diagnosticsChannel.unsubscribe?.(channel, listener));
+			}
+			return () => {
+				if (disposed) return;
+				disposed = true;
+				for (const dispose of disposers) dispose();
+			};
+		}
+	};
+}
+function loadDiagnosticsChannel() {
+	if (cachedDiagnosticsChannel !== void 0) return cachedDiagnosticsChannel;
+	try {
+		cachedDiagnosticsChannel = requireBuiltin("node:diagnostics_channel");
+	} catch {
+		try {
+			cachedDiagnosticsChannel = requireBuiltin("diagnostics_channel");
+		} catch {
+			cachedDiagnosticsChannel = null;
+		}
+	}
+	return cachedDiagnosticsChannel;
+}
+//#endregion
+exports.captureCliIntegration = captureCliIntegration;
+exports.captureProcessIntegration = captureProcessIntegration;
+exports.createAsyncLocalStorageContextManager = createAsyncLocalStorageContextManager;
+exports.databaseIntegration = databaseIntegration;
+exports.diagnosticsChannelIntegration = diagnosticsChannelIntegration;
+exports.expressIntegration = expressIntegration;
+exports.fastifyIntegration = fastifyIntegration;
+exports.fileTransport = fileTransport;
+exports.formatSyslogMessage = formatSyslogMessage;
+exports.installAsyncLocalStorageContext = installAsyncLocalStorageContext;
+exports.nodeFetchIntegration = nodeFetchIntegration;
+exports.nodeHttpClientIntegration = nodeHttpClientIntegration;
+exports.nodeHttpTransport = nodeHttpTransport;
+exports.nodeSyslogTransport = nodeSyslogTransport;
+exports.queueIntegration = queueIntegration;
+exports.rotatingFileTransport = rotatingFileTransport;
+exports.serverlessIntegration = serverlessIntegration;
+exports.stderrTransport = stderrTransport;
+exports.stdoutTransport = stdoutTransport;
+exports.workerTransport = workerTransport;
+Object.keys(_loggerjs_core).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _loggerjs_core[k];
+		}
+	});
+});
+
+//# sourceMappingURL=index.cjs.map