@foam-ai/node 0.1.0-alpha.4 → 0.1.0-alpha.5

package/dist/network-capture/collector.js

@@ -9,6 +9,7 @@ const node_crypto_1 = require("node:crypto");
 const node_zlib_1 = require("node:zlib");
 const constants_js_1 = require("../constants.js");
 const utils_js_1 = require("../utils.js");
+const redact_js_1 = require("./redact.js");
 const ALLOWED_HEADERS = new Set(constants_js_1.SAFE_NETWORK_HEADERS);
 const ATTR = {
     request: {
@@ -48,12 +49,14 @@ function setHeaderAttributes(span, direction, headers) {
     if (Object.keys(attributes).length > 0)
         span.setAttributes(attributes);
 }
+function stringEncoding(encoding) {
+    return typeof encoding === "string" && Buffer.isEncoding(encoding)
+        ? encoding
+        : "utf8";
+}
 function copyBody(value, encoding) {
     if (typeof value === "string") {
-        const enc = typeof encoding === "string" && Buffer.isEncoding(encoding)
-            ? encoding
-            : "utf8";
-        return Buffer.from(value, enc);
+        return Buffer.from(value, stringEncoding(encoding));
     }
     if (Buffer.isBuffer(value))
         return Buffer.from(value);
@@ -62,25 +65,39 @@ function copyBody(value, encoding) {
     }
     return undefined;
 }
+// Byte length of a body chunk without copying it; undefined for non-body values.
+function bodyByteLength(value, encoding) {
+    if (typeof value === "string") {
+        return Buffer.byteLength(value, stringEncoding(encoding));
+    }
+    if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) {
+        return value.byteLength;
+    }
+    return undefined;
+}
 function decodeBody(bytes, contentEncoding) {
     if (contentEncoding === undefined)
         return bytes;
     const encoding = headerValues(contentEncoding)[0]?.toLowerCase().trim();
     if (!encoding || encoding === "identity")
         return bytes;
+    // maxOutputLength turns a decompression bomb into a caught throw instead
+    // of an unrecoverable synchronous OOM allocation.
+    const limits = { maxOutputLength: constants_js_1.NETWORK_BODY_MAX_DECODE_BYTES };
     try {
-        if (encoding === "gzip" || encoding === "x-gzip")
-            return (0, node_zlib_1.gunzipSync)(bytes);
+        if (encoding === "gzip" || encoding === "x-gzip") {
+            return (0, node_zlib_1.gunzipSync)(bytes, limits);
+        }
         if (encoding === "deflate") {
             try {
-                return (0, node_zlib_1.inflateSync)(bytes);
+                return (0, node_zlib_1.inflateSync)(bytes, limits);
             }
             catch {
-                return (0, node_zlib_1.unzipSync)(bytes);
+                return (0, node_zlib_1.unzipSync)(bytes, limits);
             }
         }
         if (encoding === "br")
-            return (0, node_zlib_1.brotliDecompressSync)(bytes);
+            return (0, node_zlib_1.brotliDecompressSync)(bytes, limits);
     }
     catch {
         return undefined;
@@ -97,7 +114,7 @@ function textEncoding(contentType) {
         .find((part) => part.toLowerCase().startsWith("charset="))
         ?.slice("charset=".length)
         .toLowerCase();
-    const text = media.startsWith("text/") ||
+    const isText = media.startsWith("text/") ||
         media.endsWith("/json") ||
         media.endsWith("+json") ||
         media.endsWith("/xml") ||
@@ -106,11 +123,13 @@ function textEncoding(contentType) {
         media.endsWith("+yaml") ||
         media === "application/x-www-form-urlencoded" ||
         Boolean(charset);
-    if (!text)
+    if (!isText)
         return undefined;
-    return charset && Buffer.isEncoding(charset) ? charset : "utf8";
+    if (charset && Buffer.isEncoding(charset))
+        return charset;
+    return "utf8";
 }
-/** Last index such that `buf.subarray(0, end)` is complete UTF-8, capped at `max`. */
+// Last index such that `buf.subarray(0, end)` is complete UTF-8, capped at `max`.
 function utf8End(buf, max) {
     const end = Math.min(max, buf.byteLength);
     if (end === 0)
@@ -132,20 +151,17 @@ function utf8End(buf, max) {
                     : Number.POSITIVE_INFINITY;
     return end - (leadAt - 1) >= needed ? end : leadAt - 1;
 }
-// pcga11: Span attributes cannot carry byte arrays (OTel AttributeValue).
-// Text goes on the span; binary uses the same `http.*.body.content` name on
-// the correlated event, where log attributes accept Uint8Array.
-function spanBodyContent(decoded, contentType) {
-    const encoding = textEncoding(contentType);
-    if (encoding === undefined)
-        return undefined;
-    const limited = decoded.byteLength > constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES
-        ? decoded.subarray(0, constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES)
-        : decoded;
-    const end = encoding === "utf8" || encoding === "utf-8"
-        ? utf8End(limited, limited.byteLength)
-        : limited.byteLength;
-    return limited.subarray(0, end).toString(encoding);
+function cappedBody(buf) {
+    if (buf.byteLength <= constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES)
+        return buf;
+    return buf.subarray(0, constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES);
+}
+function decodeText(decoded, encoding) {
+    const limited = cappedBody(decoded);
+    if (encoding === "utf8" || encoding === "utf-8") {
+        return limited.subarray(0, utf8End(limited, limited.byteLength)).toString(encoding);
+    }
+    return limited.toString(encoding);
 }
 class BodyCollector {
     span;
@@ -195,17 +211,28 @@ class BodyCollector {
     observe(value, encoding) {
         if (this.finalized)
             return;
+        if (this.capturedBytes >= constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES) {
+            // Past the cap every chunk is discarded; only its length is needed
+            // (for the observed size), so skip the per-chunk copy that would
+            // otherwise double the allocation traffic of large transfers.
+            const length = bodyByteLength(value, encoding);
+            if (length === undefined)
+                return;
+            this.deadline.refresh();
+            this.observedBytes += length;
+            this.truncated = true;
+            this.span.setAttributes({
+                [this.attr.size]: this.observedBytes,
+                [this.attr.truncated]: true,
+            });
+            return;
+        }
         const bytes = copyBody(value, encoding);
         if (!bytes)
             return;
         this.deadline.refresh();
         this.observedBytes += bytes.byteLength;
         this.span.setAttribute(this.attr.size, this.observedBytes);
-        if (this.capturedBytes >= constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES) {
-            this.truncated = true;
-            this.span.setAttribute(this.attr.truncated, true);
-            return;
-        }
         const room = constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES - this.capturedBytes;
         const kept = bytes.byteLength > room ? bytes.subarray(0, room) : bytes;
         this.chunks.push(kept);
@@ -236,35 +263,52 @@ class BodyCollector {
         });
     }
     emit(buffers, headers, complete) {
-        const outcome = this.observedBytes === 0
-            ? "empty"
-            : complete
-                ? "captured"
-                : "incomplete";
+        let outcome;
+        if (this.observedBytes === 0)
+            outcome = "empty";
+        else if (complete)
+            outcome = "captured";
+        else
+            outcome = "incomplete";
         if (outcome === "empty")
             return;
-        const wire = buffers.length <= 1 ? buffers[0] : Buffer.concat(buffers);
+        let wire;
+        if (buffers.length === 0)
+            wire = undefined;
+        else if (buffers.length === 1)
+            wire = buffers[0];
+        else
+            wire = Buffer.concat(buffers);
+        // Span attributes cannot hold bytes (OTel AttributeValue). Text goes on
+        // the span; binary uses the same `http.*.body.content` name on the event.
         let binaryContent;
-        if (wire) {
+        let chunkSource = wire;
+        if (wire !== undefined) {
             const decoded = decodeBody(wire, headers["content-encoding"]);
-            const source = decoded ?? wire;
-            const text = decoded
-                ? spanBodyContent(decoded, headers["content-type"])
-                : undefined;
-            if (text !== undefined) {
-                this.span.setAttribute(this.attr.content, text);
+            if (decoded === undefined) {
+                binaryContent = Uint8Array.from(cappedBody(wire));
             }
             else {
-                const limited = source.byteLength > constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES
-                    ? source.subarray(0, constants_js_1.NETWORK_BODY_MAX_CAPTURE_BYTES)
-                    : source;
-                binaryContent = Uint8Array.from(limited);
+                const encoding = textEncoding(headers["content-type"]);
+                if (encoding !== undefined) {
+                    const redacted = (0, redact_js_1.redactBodyText)(decodeText(decoded, encoding), headers["content-type"]);
+                    this.span.setAttribute(this.attr.content, redacted.text);
+                    if (redacted.changed) {
+                        // pcga11: Chunk events must not re-ship bytes the span content
+                        // redacted, so the (possibly compressed) wire bytes are replaced
+                        // with the redacted text.
+                        chunkSource = Buffer.from(redacted.text, encoding);
+                    }
+                }
+                else {
+                    binaryContent = Uint8Array.from(cappedBody(decoded));
+                }
             }
         }
         const chunks = [];
-        if (wire) {
-            for (let i = 0; i < wire.byteLength; i += constants_js_1.NETWORK_BODY_CHUNK_BYTES) {
-                chunks.push(wire.subarray(i, i + constants_js_1.NETWORK_BODY_CHUNK_BYTES));
+        if (chunkSource) {
+            for (let i = 0; i < chunkSource.byteLength; i += constants_js_1.NETWORK_BODY_CHUNK_BYTES) {
+                chunks.push(chunkSource.subarray(i, i + constants_js_1.NETWORK_BODY_CHUNK_BYTES));
             }
         }
         const common = {

package/dist/network-capture/http.d.ts

@@ -1,5 +1,4 @@
 import type { HttpRequestCustomAttributeFunction, HttpResponseCustomAttributeFunction } from "@opentelemetry/instrumentation-http";
-/** Builds OTel HTTP request/response hooks that record headers as span attributes and stream bodies as log events. */
 export declare function createNetworkCaptureHooks(bodyCaptureEnabled?: boolean): {
     requestHook: HttpRequestCustomAttributeFunction;
     responseHook: HttpResponseCustomAttributeFunction;

package/dist/network-capture/http.js

@@ -46,7 +46,7 @@ function observeDirectHeaders(args, headers) {
         append(rawKey, value);
     }
 }
-/** Replaces a method with a wrapped version; returns an undo that restores it unless someone else re-patched it. */
+// pcga11:Replaces a method with a wrapped version; returns an undo that restores it unless someone else re-patched it.
 function swapMethod(target, key, wrap) {
     const original = target[key];
     const wrapped = wrap(original);
@@ -56,7 +56,7 @@ function swapMethod(target, key, wrap) {
             target[key] = original;
     };
 }
-/** Wraps writeHead (when present) to record inline headers; returns an undo. */
+// Wraps writeHead (when present) to record inline headers; returns an undo.
 function swapWriteHead(target, directHeaders, afterWriteHead) {
     const original = target.writeHead;
     if (!original)
@@ -75,7 +75,7 @@ function swapWriteHead(target, directHeaders, afterWriteHead) {
             target.writeHead = original;
     };
 }
-/** Attaches one-shot listeners; returns an undo that removes all of them. */
+// Attaches one-shot listeners; returns an undo that removes all of them.
 function listenOnce(target, listeners) {
     for (const [event, listener] of listeners)
         target.once(event, listener);
@@ -97,11 +97,13 @@ function observeWritableHeaders(message, span, direction, directHeaders) {
     });
     const restoreWriteHead = swapWriteHead(target, directHeaders, applyHeaders);
     let removeListeners = () => { };
-    const cleanup = () => {
+    // Runs inside the customer's EventEmitter emit; a throw here would surface
+    // as an uncaughtException in their app.
+    const cleanup = () => (0, utils_js_1.safely)(() => {
         restoreEnd();
         restoreWriteHead();
         removeListeners();
-    };
+    });
     removeListeners = listenOnce(target, [
         ["finish", cleanup],
         ["close", cleanup],
@@ -121,8 +123,8 @@ function observeReadable(message, collector) {
         });
         return result;
     });
-    const onComplete = () => collector.finalize(true);
-    const onIncomplete = () => collector.finalize(false);
+    const onComplete = () => (0, utils_js_1.safely)(() => collector.finalize(true));
+    const onIncomplete = () => (0, utils_js_1.safely)(() => collector.finalize(false));
     const removeListeners = listenOnce(target, [
         ["end", onComplete],
         ["aborted", onIncomplete],
@@ -156,8 +158,8 @@ function observeWritable(message, collector, directHeaders) {
         }
     });
     const restoreWriteHead = swapWriteHead(target, directHeaders);
-    const onComplete = () => collector.finalize(true);
-    const onIncomplete = () => collector.finalize(false);
+    const onComplete = () => (0, utils_js_1.safely)(() => collector.finalize(true));
+    const onIncomplete = () => (0, utils_js_1.safely)(() => collector.finalize(false));
     const removeListeners = listenOnce(target, [
         ["finish", onComplete],
         ["close", onIncomplete],
@@ -170,19 +172,14 @@ function observeWritable(message, collector, directHeaders) {
         removeListeners();
     });
 }
-/**
- * Instruments one HTTP message (either side, either direction) on a span:
- * records headers as `http.<direction>.header.*` attributes and, when enabled,
- * captures the body via a BodyCollector.
- */
+// pcga11: Instruments one HTTP message on a span:
+// - records headers as `http.<direction>.header.*` attributes
+// - captures the body via a BodyCollector when enabled.
 function hookMessage(span, message, direction, bodyCaptureEnabled) {
-    // Duck-type: only outgoing messages (ClientRequest/ServerResponse) have write/end.
+    // pcga11: Duck-type: only outgoing messages (ClientRequest/ServerResponse) have write/end.
     if ("write" in message && "end" in message) {
-        // A writable request is an outgoing client call; a writable response is served by us.
         const side = direction === "request" ? "client" : "server";
-        // Collects headers passed inline to writeHead(), which don't show up in getHeaders().
         const directHeaders = new Map();
-        // Eagerly record whatever headers exist right now; late-set headers are handled below.
         (0, collector_js_1.setHeaderAttributes)(span, direction, outgoingHeaders(message, directHeaders));
         const collector = bodyCaptureEnabled
             ? // Headers are passed as a lazy callback so late-set headers are seen at finalize time.
@@ -192,32 +189,33 @@ function hookMessage(span, message, direction, bodyCaptureEnabled) {
         if (collector)
             observeWritable(message, collector, directHeaders);
         else if (span.isRecording()) {
-            // No body capture: still patch end/writeHead so late-set headers land on the span.
             observeWritableHeaders(message, span, direction, directHeaders);
         }
     }
     else {
-        // Inverse of the writable case: a request arriving at us means we are the server.
         const side = direction === "request" ? "server" : "client";
-        // Incoming message: headers are fully parsed by Node before the hook runs, so snapshot once.
         const headers = incomingHeaders(message);
         (0, collector_js_1.setHeaderAttributes)(span, direction, headers);
         const collector = bodyCaptureEnabled
             ? collector_js_1.BodyCollector.create(span, side, direction, () => headers)
             : undefined;
-        // Patch the stream's push() to copy body chunks as they arrive from the socket.
         if (collector)
             observeReadable(message, collector);
     }
 }
-/** Builds OTel HTTP request/response hooks that record headers as span attributes and stream bodies as log events. */
+// pcga11: Creates network capture hooks for node:http / node:https. Wraps instance
+// methods: push(), write(), and end() on IncomingMessage / ClientRequest /
+// ServerResponse. This works for all Node versions Foam supports.
 function createNetworkCaptureHooks(bodyCaptureEnabled = true) {
+    // OTel guards hook errors today, but Foam's no-crash guarantee must not
+    // depend on that: any failure here is swallowed and the request proceeds
+    // as if Foam were not installed.
     return {
         requestHook(span, request) {
-            hookMessage(span, request, "request", bodyCaptureEnabled);
+            (0, utils_js_1.safely)(() => hookMessage(span, request, "request", bodyCaptureEnabled));
         },
         responseHook(span, response) {
-            hookMessage(span, response, "response", bodyCaptureEnabled);
+            (0, utils_js_1.safely)(() => hookMessage(span, response, "response", bodyCaptureEnabled));
         },
     };
 }

package/dist/network-capture/index.js

@@ -1,6 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUndiciNetworkCaptureHooks = exports.createNetworkCaptureHooks = void 0;
+// 
+// Advanced body capture uses three adapters across Foam's Node range:
+// 1. node:http / node:https — instance push(), write(), and end() wrapping
+//    (every supported Node version).
+// 2. Undici legacy — request:create plus instance onBodySent / onData
+//    (bundled fetch on Node 18.19, 20, 22, and 24.0–24.3, whose Undici is
+//    older than 7.11).
+// 3. Undici modern — bodyChunkSent / bodyChunkReceived channels (Undici
+//    7.11+, including Node 24.4+ and a separately installed undici). Future
+//    Node is chosen by capability: modern channels win when they fire.
 var http_js_1 = require("./http.js");
 Object.defineProperty(exports, "createNetworkCaptureHooks", { enumerable: true, get: function () { return http_js_1.createNetworkCaptureHooks; } });
 var undici_js_1 = require("./undici.js");

package/dist/network-capture/redact.d.ts

@@ -0,0 +1,6 @@
+export interface RedactionResult {
+    readonly text: string;
+    readonly changed: boolean;
+}
+export declare function isSensitiveBodyKey(key: string): boolean;
+export declare function redactBodyText(text: string, contentType: unknown): RedactionResult;

package/dist/network-capture/redact.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSensitiveBodyKey = isSensitiveBodyKey;
+exports.redactBodyText = redactBodyText;
+const constants_js_1 = require("../constants.js");
+const EXACT_KEYS = new Set(constants_js_1.SENSITIVE_BODY_KEYS_EXACT);
+function normalizeKey(key) {
+    return key.toLowerCase().replace(/[-_.\s]/g, "");
+}
+function isSensitiveBodyKey(key) {
+    const normalized = normalizeKey(key);
+    return (EXACT_KEYS.has(normalized) ||
+        constants_js_1.SENSITIVE_BODY_KEY_PATTERNS.some((pattern) => normalized.includes(pattern)));
+}
+function mediaType(contentType) {
+    const raw = Array.isArray(contentType) ? contentType[0] : contentType;
+    if (typeof raw !== "string")
+        return "";
+    return (raw.split(";")[0] ?? "").trim().toLowerCase();
+}
+function redactNode(node, state) {
+    if (Array.isArray(node)) {
+        return node.map((item) => redactNode(item, state));
+    }
+    if (node !== null && typeof node === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (isSensitiveBodyKey(key) && value !== null && value !== undefined) {
+                result[key] = constants_js_1.REDACTED_VALUE;
+                state.changed = true;
+            }
+            else {
+                result[key] = redactNode(value, state);
+            }
+        }
+        return result;
+    }
+    return node;
+}
+// pcga11: Captures a "key": value pair with a string (possibly unterminated
+// at a truncation point), number, or literal value. Used only when the body
+// does not parse as JSON, e.g. because the 1 MiB cap cut it mid-document.
+const JSON_PAIR_PATTERN = /"((?:[^"\\]|\\.)*)"(\s*:\s*)("(?:[^"\\]|\\.)*"?|-?\d[\d.eE+-]*|true|false|null)/g;
+function redactJsonFallback(text) {
+    let changed = false;
+    const redacted = text.replace(JSON_PAIR_PATTERN, (match, key, separator) => {
+        if (!isSensitiveBodyKey(key))
+            return match;
+        changed = true;
+        return `"${key}"${separator}"${constants_js_1.REDACTED_VALUE}"`;
+    });
+    return changed ? { text: redacted, changed } : { text, changed: false };
+}
+function redactJson(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return redactJsonFallback(text);
+    }
+    const state = { changed: false };
+    const redacted = redactNode(parsed, state);
+    if (!state.changed)
+        return { text, changed: false };
+    return { text: JSON.stringify(redacted), changed: true };
+}
+function redactForm(text) {
+    const params = new URLSearchParams(text);
+    let changed = false;
+    for (const key of new Set(params.keys())) {
+        if (!isSensitiveBodyKey(key))
+            continue;
+        params.set(key, constants_js_1.REDACTED_VALUE);
+        changed = true;
+    }
+    return changed ? { text: params.toString(), changed } : { text, changed: false };
+}
+function redactBodyText(text, contentType) {
+    const media = mediaType(contentType);
+    if (media === "application/x-www-form-urlencoded")
+        return redactForm(text);
+    if (media.endsWith("/json") || media.endsWith("+json")) {
+        return redactJson(text);
+    }
+    return { text, changed: false };
+}

package/dist/network-capture/undici.d.ts

@@ -1,8 +1,4 @@
 import type { RequestHookFunction, ResponseHookFunction } from "@opentelemetry/instrumentation-undici";
-/**
- * Builds OTel Undici/fetch hooks. Headers use the same allowlist as Node HTTP.
- * Bodies are copied from diagnostics_channel chunks — never from fetch streams.
- */
 export declare function createUndiciNetworkCaptureHooks(bodyCaptureEnabled?: boolean): {
     requestHook: RequestHookFunction;
     responseHook: ResponseHookFunction;

package/dist/network-capture/undici.js

@@ -6,6 +6,7 @@ const node_diagnostics_channel_1 = require("node:diagnostics_channel");
 const utils_js_1 = require("../utils.js");
 const collector_js_1 = require("./collector.js");
 const undiciSessions = new WeakMap();
+const legacyWrappedRequests = new WeakSet();
 let undiciBodyChannelsBound = false;
 function appendHeader(headers, rawName, value) {
     const name = String(rawName).toLowerCase();
@@ -90,19 +91,50 @@ function bindUndiciChannel(name, handle) {
         });
     });
 }
+function wrapLegacyBodyMethod(request, name, direction) {
+    const target = request;
+    const original = target[name];
+    if (typeof original !== "function")
+        return;
+    target[name] = function (chunk, ...rest) {
+        const result = original.call(this, chunk, ...rest);
+        (0, utils_js_1.safely)(() => {
+            const session = undiciSessions.get(request);
+            if (!session || session.modernBodyChannels)
+                return;
+            undiciCollector(session, direction)?.observe(chunk);
+        });
+        return result;
+    };
+}
+function bindLegacyUndiciBodyMethods(request) {
+    if (legacyWrappedRequests.has(request))
+        return;
+    legacyWrappedRequests.add(request);
+    wrapLegacyBodyMethod(request, "onBodySent", "request");
+    wrapLegacyBodyMethod(request, "onData", "response");
+    wrapLegacyBodyMethod(request, "onResponseData", "response");
+}
 function bindUndiciBodyChannels() {
     if (undiciBodyChannelsBound)
         return;
     undiciBodyChannelsBound = true;
-    // Subscribe before UndiciInstrumentation.enable() so trailers run while
-    // the span is still recording. BodyCollector is created on first chunk.
+    (0, node_diagnostics_channel_1.subscribe)("undici:request:create", (message) => {
+        (0, utils_js_1.safely)(() => {
+            const request = undiciRequest(message);
+            if (request)
+                bindLegacyUndiciBodyMethods(request);
+        });
+    });
     bindUndiciChannel("undici:request:bodyChunkSent", (message, _request, session) => {
+        session.modernBodyChannels = true;
         undiciCollector(session, "request")?.observe(message.chunk);
     });
     bindUndiciChannel("undici:request:bodySent", (_message, _request, session) => {
         session.requestBody?.finalize(true);
     });
     bindUndiciChannel("undici:request:bodyChunkReceived", (message, _request, session) => {
+        session.modernBodyChannels = true;
         undiciCollector(session, "response")?.observe(message.chunk);
     });
     bindUndiciChannel("undici:request:trailers", (_message, request) => {
@@ -112,33 +144,34 @@ function bindUndiciBodyChannels() {
         finishUndici(request, false);
     });
 }
-/**
- * Builds OTel Undici/fetch hooks. Headers use the same allowlist as Node HTTP.
- * Bodies are copied from diagnostics_channel chunks — never from fetch streams.
- */
 function createUndiciNetworkCaptureHooks(bodyCaptureEnabled = true) {
     if (bodyCaptureEnabled)
         bindUndiciBodyChannels();
     return {
         requestHook(span, request) {
-            const headers = undiciRequestHeaders(request.headers);
-            (0, collector_js_1.setHeaderAttributes)(span, "request", headers);
-            if (!bodyCaptureEnabled ||
-                !span.isRecording() ||
-                (span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) !==
-                    api_1.TraceFlags.SAMPLED) {
-                return;
-            }
-            undiciSessions.set(request, { span, requestHeaders: headers });
+            (0, utils_js_1.safely)(() => {
+                const headers = undiciRequestHeaders(request.headers);
+                (0, collector_js_1.setHeaderAttributes)(span, "request", headers);
+                if (!bodyCaptureEnabled ||
+                    !span.isRecording() ||
+                    (span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) !==
+                        api_1.TraceFlags.SAMPLED) {
+                    return;
+                }
+                undiciSessions.set(request, { span, requestHeaders: headers });
+                bindLegacyUndiciBodyMethods(request);
+            });
         },
         responseHook(span, info) {
-            const headers = undiciResponseHeaders(info.response.headers);
-            (0, collector_js_1.setHeaderAttributes)(span, "response", headers);
-            if (!bodyCaptureEnabled || info.request === undefined)
-                return;
-            const session = undiciSessions.get(info.request);
-            if (session)
-                session.responseHeaders = headers;
+            (0, utils_js_1.safely)(() => {
+                const headers = undiciResponseHeaders(info.response.headers);
+                (0, collector_js_1.setHeaderAttributes)(span, "response", headers);
+                if (!bodyCaptureEnabled || info.request === undefined)
+                    return;
+                const session = undiciSessions.get(info.request);
+                if (session)
+                    session.responseHeaders = headers;
+            });
         },
     };
 }

package/dist/otlp.d.ts

@@ -0,0 +1,8 @@
+import type { SeverityNumber } from "@opentelemetry/api-logs";
+export declare function sendOtlpLog({ token, resourceAttributes, scopeName, severityNumber, body, }: {
+    token: string;
+    resourceAttributes: Record<string, string>;
+    scopeName: string;
+    severityNumber: SeverityNumber;
+    body: string;
+}): Promise<void>;