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

package/dist/instrumentations.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentationName = void 0;
+exports.buildInstrumentations = buildInstrumentations;
+const auto_instrumentations_node_1 = require("@opentelemetry/auto-instrumentations-node");
+const instrumentation_console_1 = require("@opentelemetry/instrumentation-console");
+const index_js_1 = require("./network-capture/index.js");
+const endpoint_js_1 = require("./endpoint.js");
+const state_js_1 = require("./state.js");
+const constants_js_1 = require("./constants.js");
+function buildInstrumentations(networkCapture = "basic", disableLogSending = false, ignoredOutboundHosts, additionalInstrumentations) {
+    // pcga11: Captured bodies are emitted through the global logs pipeline. Only enable
+    // capture when that pipeline delivers to Foam ("global"/"ingest").
+    // If another SDK owns the slot (aka we have "local" for logs), capturing would be done for other vendors instead of Foam which might be non-compliant.
+    // If it's "none", capturing does not work at all.
+    const logsSource = (0, state_js_1.getSignal)(state_js_1.Signals.logs);
+    const bodyCaptureEnabled = logsSource === state_js_1.SignalSources.global || logsSource === state_js_1.SignalSources.ingest;
+    const capturedHeaders = networkCapture === "off" ? undefined : [...constants_js_1.SAFE_NETWORK_HEADERS];
+    // pcga11: Skip Foam's OTLP export HTTP calls so they do not become client spans
+    // TODO(pcga11): This could get real interesting: could we use these calls to verify coverage? IDK maybe tarpid
+    const ignoredHosts = new Set([
+        new URL(endpoint_js_1.endpoint).hostname,
+        ...(ignoredOutboundHosts ?? []),
+    ]);
+    const ignoreHttpOutgoingRequest = ((request) => typeof request.hostname === "string" &&
+        ignoredHosts.has(request.hostname));
+    const ignoreUndiciRequest = ((request) => {
+        try {
+            return ignoredHosts.has(new URL(request.origin).hostname);
+        }
+        catch {
+            return false;
+        }
+    });
+    const bodyHooks = networkCapture === "advanced"
+        ? (0, index_js_1.createNetworkCaptureHooks)(bodyCaptureEnabled)
+        : undefined;
+    const advancedUndiciHooks = networkCapture === "advanced"
+        ? (0, index_js_1.createUndiciNetworkCaptureHooks)(bodyCaptureEnabled)
+        : undefined;
+    const automatic = (0, auto_instrumentations_node_1.getNodeAutoInstrumentations)({
+        "@opentelemetry/instrumentation-bunyan": {
+            disableLogSending: disableLogSending === true,
+        },
+        "@opentelemetry/instrumentation-http": {
+            ...(capturedHeaders
+                ? {
+                    headersToSpanAttributes: {
+                        client: {
+                            requestHeaders: capturedHeaders,
+                            responseHeaders: capturedHeaders,
+                        },
+                        server: {
+                            requestHeaders: capturedHeaders,
+                            responseHeaders: capturedHeaders,
+                        },
+                    },
+                }
+                : {}),
+            ...(bodyHooks ?? {}),
+            ignoreOutgoingRequestHook: ignoreHttpOutgoingRequest,
+        },
+        "@opentelemetry/instrumentation-openai": {
+            captureMessageContent: networkCapture === "advanced",
+        },
+        "@opentelemetry/instrumentation-pino": {
+            disableLogSending: disableLogSending === true,
+        },
+        "@opentelemetry/instrumentation-undici": {
+            ...(capturedHeaders
+                ? {
+                    headersToSpanAttributes: {
+                        requestHeaders: capturedHeaders,
+                        responseHeaders: capturedHeaders,
+                    },
+                }
+                : {}),
+            ...(advancedUndiciHooks ?? {}),
+            ignoreRequestHook: ignoreUndiciRequest,
+        },
+        "@opentelemetry/instrumentation-winston": {
+            disableLogSending: disableLogSending === true,
+        },
+    });
+    const instrumentations = [
+        ...automatic,
+        // pcga11: Ignores disableLogSending: console has no in-process transports to double-ship through.
+        new instrumentation_console_1.ConsoleInstrumentation(),
+        ...(additionalInstrumentations ?? []),
+    ];
+    // pcga11: Last entry per name wins: user entries win over our defaults, so on a name
+    // collision the map holds our instance as they come first in the list and we disable it.
+    const unique = new Map();
+    for (const entry of instrumentations) {
+        unique.get(entry.instrumentationName)?.disable();
+        unique.set(entry.instrumentationName, entry);
+    }
+    return [...unique.values()];
+}
+const instrumentationName = (instrumentation) => instrumentation.instrumentationName.replace(/^@opentelemetry\/instrumentation-/, "");
+exports.instrumentationName = instrumentationName;

package/dist/logs.d.ts

@@ -0,0 +1,9 @@
+import type { Attributes } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+export declare function setFoamLoggerProvider(provider: LoggerProvider): void;
+export declare function getFoamLoggerProvider(): LoggerProvider | undefined;
+export declare function clearFoamLoggerProvider(): void;
+export declare function ensureFoamLoggerProvider(name: string, environment: string, token: string, stamp?: Attributes): LoggerProvider;
+export declare const log: (body: string, severityNumber?: SeverityNumber, attributes?: Attributes) => void;
+export { SeverityNumber };

package/dist/logs.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeverityNumber = exports.log = void 0;
+exports.setFoamLoggerProvider = setFoamLoggerProvider;
+exports.getFoamLoggerProvider = getFoamLoggerProvider;
+exports.clearFoamLoggerProvider = clearFoamLoggerProvider;
+exports.ensureFoamLoggerProvider = ensureFoamLoggerProvider;
+const api_logs_1 = require("@opentelemetry/api-logs");
+Object.defineProperty(exports, "SeverityNumber", { enumerable: true, get: function () { return api_logs_1.SeverityNumber; } });
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const constants_js_1 = require("./constants.js");
+const exporters_js_1 = require("./exporters.js");
+const resource_js_1 = require("./resource.js");
+const utils_js_1 = require("./utils.js");
+let foamLoggerProvider;
+function setFoamLoggerProvider(provider) {
+    if (foamLoggerProvider && foamLoggerProvider !== provider) {
+        void foamLoggerProvider.shutdown().catch(() => undefined);
+    }
+    foamLoggerProvider = provider;
+}
+function getFoamLoggerProvider() {
+    return foamLoggerProvider;
+}
+function clearFoamLoggerProvider() {
+    foamLoggerProvider = undefined;
+}
+function ensureFoamLoggerProvider(name, environment, token, stamp) {
+    const existing = foamLoggerProvider;
+    if (existing) {
+        return existing;
+    }
+    const provider = new sdk_logs_1.LoggerProvider({
+        resource: (0, resource_js_1.createFoamResource)(name, environment),
+        processors: [
+            new sdk_logs_1.BatchLogRecordProcessor({
+                exporter: new exporters_js_1.FoamLogExporter(token, stamp),
+            }),
+        ],
+    });
+    setFoamLoggerProvider(provider);
+    process.once("beforeExit", () => {
+        void provider.shutdown().catch(() => undefined);
+    });
+    return provider;
+}
+const log = (body, severityNumber = api_logs_1.SeverityNumber.INFO, attributes) => {
+    const provider = foamLoggerProvider;
+    if (!provider) {
+        return;
+    }
+    (0, utils_js_1.safely)(() => {
+        provider.getLogger(constants_js_1.FOAM_DISTRO_NAME, constants_js_1.FOAM_DISTRO_VERSION).emit({
+            body,
+            severityNumber,
+            severityText: constants_js_1.SEVERITY_TEXT[severityNumber],
+            attributes,
+        });
+    });
+};
+exports.log = log;

package/dist/metrics.d.ts

@@ -0,0 +1,5 @@
+import { type Attributes, type MetricOptions } from "@opentelemetry/api";
+export declare const incrementCounter: (name: string, n?: number | undefined, attributes?: Attributes | undefined, options?: MetricOptions | undefined) => void;
+export declare const recordHistogram: (name: string, value: number, attributes?: Attributes | undefined, options?: MetricOptions | undefined) => void;
+export declare const addUpDownCounter: (name: string, n: number, attributes?: Attributes | undefined, options?: MetricOptions | undefined) => void;
+export declare const setMetric: (name: string, value: number, attributes?: Attributes | undefined, options?: MetricOptions | undefined) => void;

package/dist/metrics.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMetric = exports.addUpDownCounter = exports.recordHistogram = exports.incrementCounter = void 0;
+const api_1 = require("@opentelemetry/api");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const constants_js_1 = require("./constants.js");
+const utils_js_1 = require("./utils.js");
+const state_js_1 = require("./state.js");
+const instruments = new Map();
+const meter = () => api_1.metrics.getMeter(constants_js_1.FOAM_DISTRO_NAME);
+// pcga11: We use cache to avoid wasting time searching for the meter every time we need to create an instrument.
+function cachedInstrument(type, name, create) {
+    const key = `${type}:${name}`;
+    if (!instruments.has(key))
+        instruments.set(key, create());
+    return instruments.get(key);
+}
+exports.incrementCounter = (0, utils_js_1.whenInitialized)(state_js_1.Signals.metrics, (name, n = 1, attributes, options = {}) => {
+    cachedInstrument(sdk_metrics_1.InstrumentType.COUNTER, name, () => meter().createCounter(name, options)).add(n, attributes);
+});
+exports.recordHistogram = (0, utils_js_1.whenInitialized)(state_js_1.Signals.metrics, (name, value, attributes, options = {}) => {
+    cachedInstrument(sdk_metrics_1.InstrumentType.HISTOGRAM, name, () => meter().createHistogram(name, options)).record(value, attributes);
+});
+exports.addUpDownCounter = (0, utils_js_1.whenInitialized)(state_js_1.Signals.metrics, (name, n, attributes, options = {}) => {
+    cachedInstrument(sdk_metrics_1.InstrumentType.UP_DOWN_COUNTER, name, () => meter().createUpDownCounter(name, options)).add(n, attributes);
+});
+exports.setMetric = (0, utils_js_1.whenInitialized)(state_js_1.Signals.metrics, (name, value, attributes, options = {}) => {
+    cachedInstrument(sdk_metrics_1.InstrumentType.GAUGE, name, () => meter().createGauge(name, options)).record(value, attributes);
+});

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

@@ -0,0 +1,27 @@
+import { type Context, type Span } from "@opentelemetry/api";
+export type CaptureDirection = "request" | "response";
+export type CaptureSide = "client" | "server";
+export type HeaderSnapshot = Readonly<Record<string, unknown>>;
+export declare function setHeaderAttributes(span: Span, direction: CaptureDirection, headers: HeaderSnapshot): void;
+export declare class BodyCollector {
+    private readonly span;
+    private readonly context;
+    private readonly side;
+    private readonly direction;
+    private readonly headers;
+    private readonly id;
+    private readonly attr;
+    private readonly chunks;
+    private readonly cleanups;
+    private readonly deadline;
+    private observedBytes;
+    private capturedBytes;
+    private truncated;
+    private finalized;
+    constructor(span: Span, context: Context, side: CaptureSide, direction: CaptureDirection, headers: () => HeaderSnapshot);
+    static create(span: Span, side: CaptureSide, direction: CaptureDirection, headers: () => HeaderSnapshot): BodyCollector | undefined;
+    addCleanup(cleanup: () => void): void;
+    observe(value: unknown, encoding?: unknown): void;
+    finalize(complete: boolean): void;
+    private emit;
+}

package/dist/network-capture/collector.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyCollector = void 0;
+exports.setHeaderAttributes = setHeaderAttributes;
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+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: {
+        header: semantic_conventions_1.ATTR_HTTP_REQUEST_HEADER,
+        size: constants_js_1.ATTR_HTTP_REQUEST_BODY_SIZE,
+        content: constants_js_1.ATTR_HTTP_REQUEST_BODY_CONTENT,
+        captureId: constants_js_1.ATTR_FOAM_HTTP_REQUEST_BODY_CAPTURE_ID,
+        complete: constants_js_1.ATTR_FOAM_HTTP_REQUEST_BODY_COMPLETE,
+        truncated: constants_js_1.ATTR_FOAM_HTTP_REQUEST_BODY_TRUNCATED,
+    },
+    response: {
+        header: semantic_conventions_1.ATTR_HTTP_RESPONSE_HEADER,
+        size: constants_js_1.ATTR_HTTP_RESPONSE_BODY_SIZE,
+        content: constants_js_1.ATTR_HTTP_RESPONSE_BODY_CONTENT,
+        captureId: constants_js_1.ATTR_FOAM_HTTP_RESPONSE_BODY_CAPTURE_ID,
+        complete: constants_js_1.ATTR_FOAM_HTTP_RESPONSE_BODY_COMPLETE,
+        truncated: constants_js_1.ATTR_FOAM_HTTP_RESPONSE_BODY_TRUNCATED,
+    },
+};
+let activeCaptures = 0;
+function captureLogger() {
+    return api_logs_1.logs.getLogger(constants_js_1.FOAM_DISTRO_NAME, constants_js_1.FOAM_DISTRO_VERSION);
+}
+function headerValues(value) {
+    return Array.isArray(value) ? value.map(String) : [String(value)];
+}
+function setHeaderAttributes(span, direction, headers) {
+    const attributes = {};
+    for (const [rawName, rawValue] of Object.entries(headers)) {
+        if (rawValue === undefined)
+            continue;
+        const name = rawName.toLowerCase();
+        if (!ALLOWED_HEADERS.has(name))
+            continue;
+        attributes[ATTR[direction].header(name)] = headerValues(rawValue);
+    }
+    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") {
+        return Buffer.from(value, stringEncoding(encoding));
+    }
+    if (Buffer.isBuffer(value))
+        return Buffer.from(value);
+    if (ArrayBuffer.isView(value)) {
+        return Buffer.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    }
+    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, limits);
+        }
+        if (encoding === "deflate") {
+            try {
+                return (0, node_zlib_1.inflateSync)(bytes, limits);
+            }
+            catch {
+                return (0, node_zlib_1.unzipSync)(bytes, limits);
+            }
+        }
+        if (encoding === "br")
+            return (0, node_zlib_1.brotliDecompressSync)(bytes, limits);
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function textEncoding(contentType) {
+    const raw = headerValues(contentType)[0];
+    if (raw === undefined)
+        return undefined;
+    const parts = raw.split(";").map((part) => part.trim());
+    const media = (parts[0] ?? "").toLowerCase();
+    const charset = parts
+        .find((part) => part.toLowerCase().startsWith("charset="))
+        ?.slice("charset=".length)
+        .toLowerCase();
+    const isText = media.startsWith("text/") ||
+        media.endsWith("/json") ||
+        media.endsWith("+json") ||
+        media.endsWith("/xml") ||
+        media.endsWith("+xml") ||
+        media.endsWith("/yaml") ||
+        media.endsWith("+yaml") ||
+        media === "application/x-www-form-urlencoded" ||
+        Boolean(charset);
+    if (!isText)
+        return undefined;
+    if (charset && Buffer.isEncoding(charset))
+        return charset;
+    return "utf8";
+}
+// 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)
+        return 0;
+    let leadAt = end;
+    while (leadAt > 0 && (buf[leadAt - 1] & 0xc0) === 0x80)
+        leadAt--;
+    if (leadAt === 0)
+        return 0;
+    const lead = buf[leadAt - 1];
+    const needed = (lead & 0x80) === 0
+        ? 1
+        : (lead & 0xe0) === 0xc0
+            ? 2
+            : (lead & 0xf0) === 0xe0
+                ? 3
+                : (lead & 0xf8) === 0xf0
+                    ? 4
+                    : Number.POSITIVE_INFINITY;
+    return end - (leadAt - 1) >= needed ? end : leadAt - 1;
+}
+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;
+    context;
+    side;
+    direction;
+    headers;
+    id = (0, node_crypto_1.randomUUID)();
+    attr;
+    chunks = [];
+    cleanups = [];
+    deadline;
+    observedBytes = 0;
+    capturedBytes = 0;
+    truncated = false;
+    finalized = false;
+    constructor(span, context, side, direction, headers) {
+        this.span = span;
+        this.context = context;
+        this.side = side;
+        this.direction = direction;
+        this.headers = headers;
+        this.attr = ATTR[direction];
+        activeCaptures += 1;
+        this.deadline = setTimeout(() => this.finalize(false), constants_js_1.NETWORK_CAPTURE_DEADLINE_MS);
+        this.deadline.unref();
+        this.span.setAttribute(this.attr.captureId, this.id);
+    }
+    static create(span, side, direction, headers) {
+        const context = api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, span.spanContext());
+        if (activeCaptures >= constants_js_1.MAX_ACTIVE_CAPTURES ||
+            !span.isRecording() ||
+            (span.spanContext().traceFlags & api_1.TraceFlags.SAMPLED) !==
+                api_1.TraceFlags.SAMPLED ||
+            !captureLogger().enabled({
+                context,
+                eventName: constants_js_1.NETWORK_CAPTURE_EVENT,
+                severityNumber: api_logs_1.SeverityNumber.INFO,
+            })) {
+            return undefined;
+        }
+        return new BodyCollector(span, context, side, direction, headers);
+    }
+    addCleanup(cleanup) {
+        this.cleanups.push(cleanup);
+    }
+    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);
+        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);
+        this.capturedBytes += kept.byteLength;
+        if (kept.byteLength < bytes.byteLength) {
+            this.truncated = true;
+            this.span.setAttribute(this.attr.truncated, true);
+        }
+    }
+    finalize(complete) {
+        if (this.finalized)
+            return;
+        this.finalized = true;
+        clearTimeout(this.deadline);
+        activeCaptures -= 1;
+        for (const cleanup of this.cleanups.splice(0))
+            (0, utils_js_1.safely)(cleanup);
+        // Runs inside stream handlers; header snapshots may throw on destroyed messages.
+        (0, utils_js_1.safely)(() => {
+            const headers = this.headers();
+            setHeaderAttributes(this.span, this.direction, headers);
+            this.span.setAttributes({
+                [this.attr.complete]: complete,
+                [this.attr.truncated]: this.truncated,
+                [this.attr.size]: this.observedBytes,
+            });
+            this.emit(this.chunks.splice(0), headers, complete);
+        });
+    }
+    emit(buffers, headers, complete) {
+        let outcome;
+        if (this.observedBytes === 0)
+            outcome = "empty";
+        else if (complete)
+            outcome = "captured";
+        else
+            outcome = "incomplete";
+        if (outcome === "empty")
+            return;
+        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;
+        let chunkSource = wire;
+        if (wire !== undefined) {
+            const decoded = decodeBody(wire, headers["content-encoding"]);
+            if (decoded === undefined) {
+                binaryContent = Uint8Array.from(cappedBody(wire));
+            }
+            else {
+                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 (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 = {
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_ID]: this.id,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_SIDE]: this.side,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_DIRECTION]: this.direction,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_COMPLETE]: complete,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_TRUNCATED]: this.truncated,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_OUTCOME]: outcome,
+            [this.attr.size]: this.observedBytes,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_CAPTURED_BYTES]: this.capturedBytes,
+            [constants_js_1.ATTR_FOAM_HTTP_BODY_CHUNK_COUNT]: chunks.length,
+        };
+        for (const name of ["content-type", "content-encoding"]) {
+            if (headers[name] !== undefined) {
+                common[this.attr.header(name)] = headerValues(headers[name]);
+            }
+        }
+        const logger = captureLogger();
+        const records = chunks.length === 0 ? [undefined] : chunks;
+        records.forEach((chunk, index) => {
+            logger.emit({
+                eventName: constants_js_1.NETWORK_CAPTURE_EVENT,
+                body: constants_js_1.NETWORK_CAPTURE_EVENT_BODY,
+                severityNumber: api_logs_1.SeverityNumber.INFO,
+                severityText: constants_js_1.SEVERITY_TEXT[api_logs_1.SeverityNumber.INFO],
+                attributes: {
+                    ...common,
+                    ...(chunk
+                        ? {
+                            [constants_js_1.ATTR_FOAM_HTTP_BODY_CHUNK_INDEX]: index,
+                            [constants_js_1.ATTR_FOAM_HTTP_BODY_CHUNK_BYTES]: chunk.byteLength,
+                            [constants_js_1.ATTR_FOAM_HTTP_BODY_CHUNK_CONTENT]: Uint8Array.from(chunk),
+                        }
+                        : {}),
+                    ...(index === 0 && binaryContent
+                        ? { [this.attr.content]: binaryContent }
+                        : {}),
+                },
+                context: this.context,
+            });
+        });
+    }
+}
+exports.BodyCollector = BodyCollector;

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

@@ -0,0 +1,5 @@
+import type { HttpRequestCustomAttributeFunction, HttpResponseCustomAttributeFunction } from "@opentelemetry/instrumentation-http";
+export declare function createNetworkCaptureHooks(bodyCaptureEnabled?: boolean): {
+    requestHook: HttpRequestCustomAttributeFunction;
+    responseHook: HttpResponseCustomAttributeFunction;
+};