@clickhouse/clickstack-node 0.0.0-stage → 1.0.0-rc.1

package/dist/body/http.mjs

@@ -0,0 +1,115 @@
+import { BodyCapture, headerMap, reportFailure, responseHasNoBody } from "./rules.mjs";
+import { errorMonitor } from "node:events";
+// src/body/http.ts
+function isIncoming(message) {
+	return !("getHeader" in message);
+}
+function observe(message) {
+	const capture = new BodyCapture();
+	const copy = (chunk, encoding) => {
+		try {
+			capture.add(chunk, encoding);
+		} catch (err) {
+			reportFailure(err);
+		}
+	};
+	if (isIncoming(message)) {
+		const { headers } = message;
+		const meta = {
+			contentType: headers["content-type"],
+			contentEncoding: headers["content-encoding"],
+			contentLength: headers["content-length"]
+		};
+		const emit = message.emit.bind(message);
+		message.emit = (event, ...args) => {
+			if (event === "data") copy(args[0], message.readableEncoding);
+			return emit(event, ...args);
+		};
+		return {
+			capture,
+			meta: () => ({
+				...meta,
+				complete: message.complete
+			})
+		};
+	}
+	const wrap = (original) => (...args) => {
+		const ended = message.writableEnded;
+		const result = Reflect.apply(original, message, args);
+		if (!ended && typeof args[0] !== "function") copy(args[0], args[1]);
+		return result;
+	};
+	message.write = wrap(message.write.bind(message));
+	message.end = wrap(message.end.bind(message));
+	let written = /* @__PURE__ */ new Map();
+	if ("writeHead" in message) {
+		const response = message;
+		const writeHead = response.writeHead.bind(response);
+		response.writeHead = ((...args) => {
+			const result = writeHead(...args);
+			try {
+				const raw = args.slice(1).find((a) => typeof a === "object" && a !== null);
+				const list = Array.isArray(raw) ? raw.flat() : Object.entries(raw ?? {}).flat();
+				if (list.length > 0) written = headerMap(list);
+			} catch (err) {
+				reportFailure(err);
+			}
+			return result;
+		});
+	}
+	const header = (name) => message.getHeader(name) ?? written.get(name);
+	return {
+		capture,
+		meta: () => ({
+			contentType: header("content-type"),
+			contentEncoding: header("content-encoding"),
+			contentLength: header("content-length"),
+			complete: message.writableEnded
+		})
+	};
+}
+/**
+* Creates the `node:http` body hooks.
+*
+* @returns Hooks for `instrumentation-http`.
+*/
+function createHttpBodyHooks() {
+	const exchanges = /* @__PURE__ */ new WeakMap();
+	const finalize = (span) => {
+		try {
+			const ex = exchanges.get(span);
+			exchanges.delete(span);
+			if (ex === void 0 || !span.isRecording()) return;
+			span.setAttributes(ex.request.capture.attributes("request", ex.request.meta()));
+			if (ex.response !== void 0 && !responseHasNoBody(ex.method, ex.status?.())) span.setAttributes(ex.response.capture.attributes("response", ex.response.meta()));
+		} catch (err) {
+			reportFailure(err);
+		}
+	};
+	return {
+		requestHook(span, request) {
+			if (!span.isRecording()) return;
+			exchanges.set(span, {
+				method: request.method,
+				request: observe(request)
+			});
+			if (!isIncoming(request)) {
+				const done = () => {
+					finalize(span);
+				};
+				request.on(errorMonitor, done).on("close", done);
+			}
+		},
+		responseHook(span, response) {
+			const ex = exchanges.get(span);
+			if (ex === void 0) return;
+			ex.response = observe(response);
+			ex.status = () => response.statusCode;
+			if (!isIncoming(response)) response.on(errorMonitor, () => {
+				finalize(span);
+			});
+		},
+		finalize
+	};
+}
+export { createHttpBodyHooks };

package/dist/body/rules.cjs

@@ -0,0 +1,225 @@
+const require_env = require("../env.cjs");
+const require_semconv = require("../semconv.cjs");
+let _opentelemetry_api = require("@opentelemetry/api");
+let node_buffer = require("node:buffer");
+let node_util = require("node:util");
+// src/body/rules.ts
+/** Bytes kept per body and direction. */
+const MAX_BYTES = 8192;
+/** Key substrings whose values are redacted, matched case-insensitively. */
+const REDACT_KEYS = [
+	"password",
+	"passwd",
+	"secret",
+	"token",
+	"api_key",
+	"apikey",
+	"api-key",
+	"authorization",
+	"cookie",
+	"session"
+];
+const REDACTED = "[REDACTED]";
+const FORM = "application/x-www-form-urlencoded";
+/**
+* Reports a failure inside capture code: one warning per thread, then debug lines.
+*
+* @param err - The caught error.
+*/
+function reportFailure(err) {
+	require_env.warnOnce("capture-failed", "HTTP body capture failed and was skipped", err);
+	_opentelemetry_api.diag.debug("clickstack-node: HTTP body capture failed", err);
+}
+/**
+* Tells whether a response carries no body on the wire, whatever its headers say.
+*
+* @param method - Request method.
+* @param status - Response status code.
+* @returns `true` for HEAD requests and 1xx, 204 and 304 responses.
+*/
+function responseHasNoBody(method, status) {
+	return method?.toUpperCase() === "HEAD" || status === 204 || status === 304 || (status ?? 200) < 200;
+}
+/**
+* Collects a flat `[name, value, name, value]` header list (undici, or `writeHead` arguments).
+*
+* @param headers - The list; anything else gives an empty map.
+* @returns Lowercased names mapped to their values, repeated names joined with `, `.
+*/
+function headerMap(headers) {
+	const map = /* @__PURE__ */ new Map();
+	const list = Array.isArray(headers) ? headers : [];
+	for (let i = 0; i + 1 < list.length; i += 2) {
+		const name = String(list[i]).toLowerCase();
+		const value = String(list[i + 1]);
+		const previous = map.get(name);
+		map.set(name, previous === void 0 ? value : `${previous}, ${value}`);
+	}
+	return map;
+}
+function headerString(value) {
+	if (Array.isArray(value)) return value.join(", ");
+	return typeof value === "string" || typeof value === "number" ? String(value).trim() : "";
+}
+function isTextualUtf8(contentType) {
+	const [essence = "", ...params] = headerString(contentType).toLowerCase().split(";");
+	const type = essence.trim();
+	const charset = params.map((p) => p.trim()).find((p) => p.startsWith("charset="));
+	if (type === "" || type.startsWith("multipart/")) return false;
+	if (charset !== void 0) return /^charset="?utf-?8"?$/.test(charset);
+	return type.startsWith("text/") || /[/+](json|xml|yaml)$/.test(type) || type === FORM;
+}
+function isSensitive(key) {
+	const lower = key.toLowerCase();
+	return REDACT_KEYS.some((k) => lower.includes(k));
+}
+function skipSpace(text, from) {
+	let i = from;
+	while (i < text.length && /\s/.test(text.charAt(i))) i++;
+	return i;
+}
+/** Index just past the string token that starts at `from`, or -1 when the cap cut it. */
+function endOfString(text, from) {
+	for (let i = from + 1; i < text.length; i++) if (text[i] === "\\") i++;
+	else if (text[i] === "\"") return i + 1;
+	return -1;
+}
+/** Index just past the JSON value that starts at `from`; the text length when the cap cut it. */
+function endOfValue(text, from) {
+	let depth = 0;
+	for (let i = from; i < text.length; i++) {
+		const c = text.charAt(i);
+		if (c === "\"") {
+			const end = endOfString(text, i);
+			if (end === -1) return text.length;
+			if (depth === 0) return end;
+			i = end - 1;
+		} else if (c === "{" || c === "[") depth++;
+		else if (c === "}" || c === "]") {
+			if (depth === 0) return i;
+			if (--depth === 0) return i + 1;
+		} else if (depth === 0 && (c === "," || /\s/.test(c))) return i;
+	}
+	return text.length;
+}
+const ESCAPES = {
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+function unescapeJson(token) {
+	return token.slice(1, -1).replace(/\\(?:u([0-9a-fA-F]{4})|([^]))/g, (_match, hex, char) => hex !== void 0 ? String.fromCharCode(parseInt(hex, 16)) : ESCAPES[char ?? ""] ?? char ?? "");
+}
+function redactJson(text, nested = false) {
+	let out = "";
+	let copied = 0;
+	let i = 0;
+	while (i < text.length) {
+		if (text[i] !== "\"") {
+			i++;
+			continue;
+		}
+		const end = endOfString(text, i);
+		if (end === -1) break;
+		const token = text.slice(i, end);
+		const colon = skipSpace(text, end);
+		if (text[colon] !== ":") {
+			if (!nested && token.includes("\\\"")) {
+				const inner = unescapeJson(token);
+				const redacted = redactJson(inner, true);
+				if (redacted !== inner) {
+					out += text.slice(copied, i) + JSON.stringify(redacted);
+					copied = end;
+				}
+			}
+			i = end;
+			continue;
+		}
+		const start = skipSpace(text, colon + 1);
+		if (start === text.length || !isSensitive(unescapeJson(token))) {
+			i = end;
+			continue;
+		}
+		out += `${text.slice(copied, start)}"${REDACTED}"`;
+		i = copied = endOfValue(text, start);
+	}
+	return out + text.slice(copied);
+}
+function formKey(raw) {
+	return raw.replaceAll("+", " ").replace(/%([0-9a-fA-F]{2})/g, (_match, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+function redactForm(text) {
+	return text.split("&").map((pair) => {
+		const eq = pair.indexOf("=");
+		if (eq === -1) return pair;
+		const key = pair.slice(0, eq);
+		return isSensitive(formKey(key)) ? `${key}=${REDACTED}` : pair;
+	}).join("&");
+}
+/** Copies the first {@link MAX_BYTES} bytes of one body and counts every byte seen. */
+var BodyCapture = class {
+	/** Bytes seen, including those past the cap. */
+	seen = 0;
+	#kept = 0;
+	#buffer;
+	/**
+	* Adds one chunk; values other than strings and byte arrays are ignored.
+	*
+	* @param chunk - `Buffer`, `Uint8Array` or `string`.
+	* @param encoding - Encoding of a string chunk; anything else means UTF-8.
+	*/
+	add(chunk, encoding) {
+		if (typeof chunk === "string") {
+			const enc = typeof encoding === "string" && node_buffer.Buffer.isEncoding(encoding) ? encoding : "utf8";
+			this.seen += node_buffer.Buffer.byteLength(chunk, enc);
+			if (this.#kept >= 8192) return;
+			const head = /^(hex|base64(url)?)$/i.test(enc) ? chunk : chunk.slice(0, MAX_BYTES - this.#kept + 1);
+			this.#copy(node_buffer.Buffer.from(head, enc));
+		} else if (chunk instanceof Uint8Array) {
+			this.seen += chunk.byteLength;
+			this.#copy(chunk);
+		}
+	}
+	#copy(bytes) {
+		const n = Math.min(MAX_BYTES - this.#kept, bytes.byteLength);
+		if (n <= 0) return;
+		const need = this.#kept + n;
+		if (this.#buffer === void 0 || this.#buffer.length < need) {
+			const size = Math.max(need, 2 * (this.#buffer?.length ?? 0));
+			const grown = node_buffer.Buffer.alloc(Math.min(size, MAX_BYTES));
+			this.#buffer?.copy(grown, 0, 0, this.#kept);
+			this.#buffer = grown;
+		}
+		this.#buffer.set(bytes.subarray(0, n), this.#kept);
+		this.#kept = need;
+	}
+	/**
+	* Builds the size and content attributes for this body.
+	*
+	* @param direction - Which side of the exchange the body belongs to.
+	* @param meta - The body's headers and transfer state.
+	* @returns The attributes; empty for an empty body.
+	*/
+	attributes(direction, meta) {
+		const length = headerString(meta.contentLength);
+		const size = /^\d+$/.test(length) && (meta.complete || this.seen === 0) ? Number(length) : this.seen;
+		if (size === 0) return {};
+		const request = direction === "request";
+		const attributes = { [request ? require_semconv.ATTR_HTTP_REQUEST_BODY_SIZE : require_semconv.ATTR_HTTP_RESPONSE_BODY_SIZE]: size };
+		const coding = headerString(meta.contentEncoding).toLowerCase();
+		if (this.#buffer === void 0 || coding !== "" && coding !== "identity") return attributes;
+		if (!isTextualUtf8(meta.contentType)) return attributes;
+		let text = new node_util.TextDecoder().decode(this.#buffer.subarray(0, this.#kept), { stream: this.seen > this.#kept });
+		if (headerString(meta.contentType).toLowerCase().startsWith(FORM)) text = redactForm(text);
+		attributes[request ? require_semconv.ATTR_HTTP_REQUEST_BODY_CONTENT : require_semconv.ATTR_HTTP_RESPONSE_BODY_CONTENT] = redactJson(text);
+		return attributes;
+	}
+};
+exports.BodyCapture = BodyCapture;
+exports.MAX_BYTES = MAX_BYTES;
+exports.REDACT_KEYS = REDACT_KEYS;
+exports.headerMap = headerMap;
+exports.reportFailure = reportFailure;
+exports.responseHasNoBody = responseHasNoBody;

package/dist/body/rules.mjs

@@ -0,0 +1,220 @@
+import { warnOnce } from "../env.mjs";
+import { ATTR_HTTP_REQUEST_BODY_CONTENT, ATTR_HTTP_REQUEST_BODY_SIZE, ATTR_HTTP_RESPONSE_BODY_CONTENT, ATTR_HTTP_RESPONSE_BODY_SIZE } from "../semconv.mjs";
+import { diag } from "@opentelemetry/api";
+import { Buffer } from "node:buffer";
+import { TextDecoder } from "node:util";
+// src/body/rules.ts
+/** Bytes kept per body and direction. */
+const MAX_BYTES = 8192;
+/** Key substrings whose values are redacted, matched case-insensitively. */
+const REDACT_KEYS = [
+	"password",
+	"passwd",
+	"secret",
+	"token",
+	"api_key",
+	"apikey",
+	"api-key",
+	"authorization",
+	"cookie",
+	"session"
+];
+const REDACTED = "[REDACTED]";
+const FORM = "application/x-www-form-urlencoded";
+/**
+* Reports a failure inside capture code: one warning per thread, then debug lines.
+*
+* @param err - The caught error.
+*/
+function reportFailure(err) {
+	warnOnce("capture-failed", "HTTP body capture failed and was skipped", err);
+	diag.debug("clickstack-node: HTTP body capture failed", err);
+}
+/**
+* Tells whether a response carries no body on the wire, whatever its headers say.
+*
+* @param method - Request method.
+* @param status - Response status code.
+* @returns `true` for HEAD requests and 1xx, 204 and 304 responses.
+*/
+function responseHasNoBody(method, status) {
+	return method?.toUpperCase() === "HEAD" || status === 204 || status === 304 || (status ?? 200) < 200;
+}
+/**
+* Collects a flat `[name, value, name, value]` header list (undici, or `writeHead` arguments).
+*
+* @param headers - The list; anything else gives an empty map.
+* @returns Lowercased names mapped to their values, repeated names joined with `, `.
+*/
+function headerMap(headers) {
+	const map = /* @__PURE__ */ new Map();
+	const list = Array.isArray(headers) ? headers : [];
+	for (let i = 0; i + 1 < list.length; i += 2) {
+		const name = String(list[i]).toLowerCase();
+		const value = String(list[i + 1]);
+		const previous = map.get(name);
+		map.set(name, previous === void 0 ? value : `${previous}, ${value}`);
+	}
+	return map;
+}
+function headerString(value) {
+	if (Array.isArray(value)) return value.join(", ");
+	return typeof value === "string" || typeof value === "number" ? String(value).trim() : "";
+}
+function isTextualUtf8(contentType) {
+	const [essence = "", ...params] = headerString(contentType).toLowerCase().split(";");
+	const type = essence.trim();
+	const charset = params.map((p) => p.trim()).find((p) => p.startsWith("charset="));
+	if (type === "" || type.startsWith("multipart/")) return false;
+	if (charset !== void 0) return /^charset="?utf-?8"?$/.test(charset);
+	return type.startsWith("text/") || /[/+](json|xml|yaml)$/.test(type) || type === FORM;
+}
+function isSensitive(key) {
+	const lower = key.toLowerCase();
+	return REDACT_KEYS.some((k) => lower.includes(k));
+}
+function skipSpace(text, from) {
+	let i = from;
+	while (i < text.length && /\s/.test(text.charAt(i))) i++;
+	return i;
+}
+/** Index just past the string token that starts at `from`, or -1 when the cap cut it. */
+function endOfString(text, from) {
+	for (let i = from + 1; i < text.length; i++) if (text[i] === "\\") i++;
+	else if (text[i] === "\"") return i + 1;
+	return -1;
+}
+/** Index just past the JSON value that starts at `from`; the text length when the cap cut it. */
+function endOfValue(text, from) {
+	let depth = 0;
+	for (let i = from; i < text.length; i++) {
+		const c = text.charAt(i);
+		if (c === "\"") {
+			const end = endOfString(text, i);
+			if (end === -1) return text.length;
+			if (depth === 0) return end;
+			i = end - 1;
+		} else if (c === "{" || c === "[") depth++;
+		else if (c === "}" || c === "]") {
+			if (depth === 0) return i;
+			if (--depth === 0) return i + 1;
+		} else if (depth === 0 && (c === "," || /\s/.test(c))) return i;
+	}
+	return text.length;
+}
+const ESCAPES = {
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+function unescapeJson(token) {
+	return token.slice(1, -1).replace(/\\(?:u([0-9a-fA-F]{4})|([^]))/g, (_match, hex, char) => hex !== void 0 ? String.fromCharCode(parseInt(hex, 16)) : ESCAPES[char ?? ""] ?? char ?? "");
+}
+function redactJson(text, nested = false) {
+	let out = "";
+	let copied = 0;
+	let i = 0;
+	while (i < text.length) {
+		if (text[i] !== "\"") {
+			i++;
+			continue;
+		}
+		const end = endOfString(text, i);
+		if (end === -1) break;
+		const token = text.slice(i, end);
+		const colon = skipSpace(text, end);
+		if (text[colon] !== ":") {
+			if (!nested && token.includes("\\\"")) {
+				const inner = unescapeJson(token);
+				const redacted = redactJson(inner, true);
+				if (redacted !== inner) {
+					out += text.slice(copied, i) + JSON.stringify(redacted);
+					copied = end;
+				}
+			}
+			i = end;
+			continue;
+		}
+		const start = skipSpace(text, colon + 1);
+		if (start === text.length || !isSensitive(unescapeJson(token))) {
+			i = end;
+			continue;
+		}
+		out += `${text.slice(copied, start)}"${REDACTED}"`;
+		i = copied = endOfValue(text, start);
+	}
+	return out + text.slice(copied);
+}
+function formKey(raw) {
+	return raw.replaceAll("+", " ").replace(/%([0-9a-fA-F]{2})/g, (_match, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+function redactForm(text) {
+	return text.split("&").map((pair) => {
+		const eq = pair.indexOf("=");
+		if (eq === -1) return pair;
+		const key = pair.slice(0, eq);
+		return isSensitive(formKey(key)) ? `${key}=${REDACTED}` : pair;
+	}).join("&");
+}
+/** Copies the first {@link MAX_BYTES} bytes of one body and counts every byte seen. */
+var BodyCapture = class {
+	/** Bytes seen, including those past the cap. */
+	seen = 0;
+	#kept = 0;
+	#buffer;
+	/**
+	* Adds one chunk; values other than strings and byte arrays are ignored.
+	*
+	* @param chunk - `Buffer`, `Uint8Array` or `string`.
+	* @param encoding - Encoding of a string chunk; anything else means UTF-8.
+	*/
+	add(chunk, encoding) {
+		if (typeof chunk === "string") {
+			const enc = typeof encoding === "string" && Buffer.isEncoding(encoding) ? encoding : "utf8";
+			this.seen += Buffer.byteLength(chunk, enc);
+			if (this.#kept >= 8192) return;
+			const head = /^(hex|base64(url)?)$/i.test(enc) ? chunk : chunk.slice(0, MAX_BYTES - this.#kept + 1);
+			this.#copy(Buffer.from(head, enc));
+		} else if (chunk instanceof Uint8Array) {
+			this.seen += chunk.byteLength;
+			this.#copy(chunk);
+		}
+	}
+	#copy(bytes) {
+		const n = Math.min(MAX_BYTES - this.#kept, bytes.byteLength);
+		if (n <= 0) return;
+		const need = this.#kept + n;
+		if (this.#buffer === void 0 || this.#buffer.length < need) {
+			const size = Math.max(need, 2 * (this.#buffer?.length ?? 0));
+			const grown = Buffer.alloc(Math.min(size, MAX_BYTES));
+			this.#buffer?.copy(grown, 0, 0, this.#kept);
+			this.#buffer = grown;
+		}
+		this.#buffer.set(bytes.subarray(0, n), this.#kept);
+		this.#kept = need;
+	}
+	/**
+	* Builds the size and content attributes for this body.
+	*
+	* @param direction - Which side of the exchange the body belongs to.
+	* @param meta - The body's headers and transfer state.
+	* @returns The attributes; empty for an empty body.
+	*/
+	attributes(direction, meta) {
+		const length = headerString(meta.contentLength);
+		const size = /^\d+$/.test(length) && (meta.complete || this.seen === 0) ? Number(length) : this.seen;
+		if (size === 0) return {};
+		const request = direction === "request";
+		const attributes = { [request ? ATTR_HTTP_REQUEST_BODY_SIZE : ATTR_HTTP_RESPONSE_BODY_SIZE]: size };
+		const coding = headerString(meta.contentEncoding).toLowerCase();
+		if (this.#buffer === void 0 || coding !== "" && coding !== "identity") return attributes;
+		if (!isTextualUtf8(meta.contentType)) return attributes;
+		let text = new TextDecoder().decode(this.#buffer.subarray(0, this.#kept), { stream: this.seen > this.#kept });
+		if (headerString(meta.contentType).toLowerCase().startsWith(FORM)) text = redactForm(text);
+		attributes[request ? ATTR_HTTP_REQUEST_BODY_CONTENT : ATTR_HTTP_RESPONSE_BODY_CONTENT] = redactJson(text);
+		return attributes;
+	}
+};
+export { BodyCapture, MAX_BYTES, REDACT_KEYS, headerMap, reportFailure, responseHasNoBody };

package/dist/body/undici.cjs

@@ -0,0 +1,88 @@
+const require_env = require("../env.cjs");
+const require_rules = require("./rules.cjs");
+let node_diagnostics_channel = require("node:diagnostics_channel");
+// src/body/undici.ts
+const side = (headers, contentLength) => ({
+	capture: new require_rules.BodyCapture(),
+	meta: {
+		contentType: headers.get("content-type"),
+		contentEncoding: headers.get("content-encoding"),
+		contentLength
+	}
+});
+/**
+* Tells whether the undici that Node bundles publishes the body diagnostics channels.
+*
+* @returns `true` from undici 7.11, which Node bundles from 24.4.
+*/
+function hasBodyChannels() {
+	const [major = 0, minor = 0] = (process.versions["undici"] ?? "0").split(".").map(Number);
+	return major > 7 || major === 7 && minor >= 11;
+}
+/**
+* Creates the fetch body capture from the undici body diagnostics channels, which Node bundles
+* from 24.4 (undici 7.11). Call it before `instrumentation-undici` is constructed: that
+* instrumentation ends the span in its own trailers and error subscribers, and subscribers run
+* in subscription order, so ours must come first to write while the span is open.
+*
+* @returns The capture, or `undefined` (with one warning) when this Node has no body channels.
+*/
+function createUndiciBodyCapture() {
+	if (!hasBodyChannels()) {
+		require_env.warnOnce("undici-bodies", `fetch bodies are captured from Node.js 24.4; ${process.version} has no undici body channels`);
+		return;
+	}
+	const exchanges = /* @__PURE__ */ new WeakMap();
+	const listeners = [];
+	const listen = (name, handle) => {
+		const listener = (message) => {
+			try {
+				const { request } = message;
+				handle(request, message);
+			} catch (err) {
+				require_rules.reportFailure(err);
+			}
+		};
+		(0, node_diagnostics_channel.subscribe)(name, listener);
+		listeners.push([name, listener]);
+	};
+	const chunk = (direction) => (request, message) => {
+		exchanges.get(request)?.[direction]?.capture.add(message.chunk);
+	};
+	const finish = (cut) => (request) => {
+		const ex = exchanges.get(request);
+		exchanges.delete(request);
+		if (!ex?.span.isRecording()) return;
+		for (const direction of ["request", "response"]) {
+			const s = ex[direction];
+			if (s !== void 0) ex.span.setAttributes(s.capture.attributes(direction, {
+				...s.meta,
+				complete: !cut
+			}));
+		}
+	};
+	listen("undici:request:bodyChunkSent", chunk("request"));
+	listen("undici:request:bodyChunkReceived", chunk("response"));
+	listen("undici:request:trailers", finish(false));
+	listen("undici:request:error", finish(true));
+	return {
+		requestHook(span, request) {
+			if (!span.isRecording()) return;
+			exchanges.set(request, {
+				span,
+				request: side(require_rules.headerMap(request.headers), request.contentLength)
+			});
+		},
+		responseHook(_span, { request, response }) {
+			const ex = exchanges.get(request);
+			if (ex === void 0 || require_rules.responseHasNoBody(request.method, response.statusCode)) return;
+			const headers = require_rules.headerMap(response.headers);
+			ex.response = side(headers, headers.get("content-length"));
+		},
+		unsubscribe() {
+			for (const [name, listener] of listeners) (0, node_diagnostics_channel.unsubscribe)(name, listener);
+		}
+	};
+}
+exports.createUndiciBodyCapture = createUndiciBodyCapture;
+exports.hasBodyChannels = hasBodyChannels;