@foam-ai/node 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/init.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
+const core_1 = require("@opentelemetry/core");
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const resource_js_1 = require("./resource.js");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const report_js_1 = require("./report.js");
+const exporters_js_1 = require("./exporters.js");
+const instrumentations_js_1 = require("./instrumentations.js");
+const before_send_js_1 = require("./before-send.js");
+const logs_js_1 = require("./logs.js");
+const redaction_js_1 = require("./redaction.js");
+const state_js_1 = require("./state.js");
+// TODO(pcga11): conflicts handling pending.
+function init(options) {
+    const { sampleRate = 1, disableLogSending = false, networkCapture = "basic", enabled = true, } = options;
+    const redactionConfig = (0, redaction_js_1.resolveRedactionConfig)(options.redact);
+    const beforeSend = (0, before_send_js_1.resolveBeforeSend)(options.beforeSend);
+    // pcga11: Set params before any early return so every state is reported, including failed or disabled attempts.
+    (0, state_js_1.setParams)({ name: options.name, environment: options.environment });
+    // pcga11: We keep this option because companies often want to turn the integration off in specific envs
+    if (!enabled) {
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.INFO,
+            message: 'SDK disabled',
+        });
+        return;
+    }
+    if (!options.token) {
+        // pcga11: Nothing can be sent without a token; report() still logs locally so this is not silent.
+        (0, report_js_1.report)({
+            severity: api_logs_1.SeverityNumber.ERROR,
+            message: 'Parameter token not provided',
+        });
+        return;
+    }
+    // pcga11: Re-initializing could register duplicate providers/instrumentations, so we track the initialization state and bail out on repeat calls
+    if ((0, state_js_1.getInitialized)()) {
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.WARN,
+            message: 'SDK already initialized',
+        });
+        return;
+    }
+    if (!options.name?.trim() || !options.environment?.trim()) {
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.ERROR,
+            message: 'Parameters name and environment not provided',
+        });
+        return;
+    }
+    if (!Number.isFinite(sampleRate) || sampleRate < 0 || sampleRate > 1) {
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.ERROR,
+            message: 'Parameter sampleRate must be a finite number between 0 and 1',
+        });
+        return;
+    }
+    // pcga11: Hoisted so the catch block can shut down providers whose batch/periodic
+    // export timers started in their constructors, even when init fails midway.
+    let tracerProvider;
+    let meterProvider;
+    try {
+        (0, redaction_js_1.setActiveRedactionConfig)(redactionConfig);
+        const resource = (0, resource_js_1.createFoamResource)(options.name, options.environment, options.version, options.additionalResourceAttributes);
+        // pcga11: The context manager is what makes the "current" context (active span, baggage)
+        // follow execution across await/callback boundaries, via Node's AsyncLocalStorage. Without
+        // one registered, spans would not nest and trace/log correlation would break. Registration
+        // is first-wins: if another SDK already installed one, we keep theirs and disable ours.
+        const contextManager = new context_async_hooks_1.AsyncLocalStorageContextManager();
+        contextManager.enable();
+        if (!api_1.context.setGlobalContextManager(contextManager)) {
+            contextManager.disable();
+        }
+        (0, state_js_1.setSignal)(state_js_1.Signals.baggage, api_1.propagation.setGlobalPropagator(new core_1.CompositePropagator({
+            propagators: [
+                new core_1.W3CTraceContextPropagator(),
+                new core_1.W3CBaggagePropagator(),
+            ],
+        })) ? state_js_1.SignalSources.global : state_js_1.SignalSources.none);
+        // pcga11: The @opentelemetry/api setters return false when another SDK already owns a slot (registration is first-wins). So we try to register our own and if it fails or already taken, nothing happens.
+        // TODO(pcga11): Implement a way to handle piggy backing the context and propagation from another SDK.
+        tracerProvider = new sdk_trace_base_1.BasicTracerProvider({
+            resource,
+            sampler: new sdk_trace_base_1.ParentBasedSampler({
+                root: new sdk_trace_base_1.TraceIdRatioBasedSampler(sampleRate),
+            }),
+            spanProcessors: [
+                new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(options.token, undefined, {
+                    redaction: redactionConfig,
+                    beforeSend,
+                })),
+                ...(options.additionalSpanProcessors ?? []),
+            ],
+        });
+        meterProvider = new sdk_metrics_1.MeterProvider({
+            resource,
+            readers: [
+                new sdk_metrics_1.PeriodicExportingMetricReader({
+                    exporter: new exporters_js_1.FoamMetricExporter(options.token, undefined, {
+                        redaction: redactionConfig,
+                    }),
+                }),
+                ...(options.additionalMetricReaders ?? []),
+            ],
+        });
+        const loggerProvider = new sdk_logs_1.LoggerProvider({
+            resource,
+            processors: [
+                new sdk_logs_1.BatchLogRecordProcessor({
+                    exporter: new exporters_js_1.FoamLogExporter(options.token, undefined, {
+                        redaction: redactionConfig,
+                        beforeSend,
+                    }),
+                }),
+                ...(options.additionalLogRecordProcessors ?? []),
+            ],
+        });
+        (0, logs_js_1.setFoamLoggerProvider)(loggerProvider);
+        // pcga11: trace/metrics/propagation setters return false when the slot is taken by another SDK. The logs setter returns whichever provider ended up registered. We use that to record the source: "global" when Foam owns the slot, "none" when another SDK does. Logs fall back to "local" because the Foam-only provider behind log() exists either way.
+        (0, state_js_1.setSignal)(state_js_1.Signals.traces, api_1.trace.setGlobalTracerProvider(tracerProvider) ? state_js_1.SignalSources.global : state_js_1.SignalSources.none);
+        (0, state_js_1.setSignal)(state_js_1.Signals.metrics, api_1.metrics.setGlobalMeterProvider(meterProvider) ? state_js_1.SignalSources.global : state_js_1.SignalSources.none);
+        (0, state_js_1.setSignal)(state_js_1.Signals.logs, api_logs_1.logs.setGlobalLoggerProvider(loggerProvider) === loggerProvider ? state_js_1.SignalSources.global : state_js_1.SignalSources.local);
+        const instrumentations = (0, instrumentations_js_1.buildInstrumentations)(networkCapture, disableLogSending, options.ignoredOutboundHosts, options.additionalInstrumentations ?? []);
+        // pcga11: registerInstrumentations turns on instrumentation "hooks". OpenTelemetry wraps supported libraries when the app imports them.
+        (0, instrumentation_1.registerInstrumentations)({ instrumentations });
+        (0, state_js_1.setInstrumentations)(instrumentations.map(instrumentations_js_1.instrumentationLabel));
+        process.once("beforeExit", () => {
+            void Promise.all([
+                (0, state_js_1.getSignal)(state_js_1.Signals.traces) === state_js_1.SignalSources.global ? tracerProvider?.shutdown() : undefined,
+                (0, state_js_1.getSignal)(state_js_1.Signals.metrics) === state_js_1.SignalSources.global ? meterProvider?.shutdown() : undefined,
+                loggerProvider.shutdown(),
+            ]).catch(() => undefined);
+        });
+        (0, state_js_1.setInitialized)(true);
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.INFO,
+            message: 'SDK initialized',
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        for (const signal of [state_js_1.Signals.traces, state_js_1.Signals.metrics, state_js_1.Signals.logs, state_js_1.Signals.baggage]) {
+            (0, state_js_1.setSignal)(signal, state_js_1.SignalSources.none);
+        }
+        void Promise.all([
+            tracerProvider?.shutdown(),
+            meterProvider?.shutdown(),
+            (0, logs_js_1.getFoamLoggerProvider)()?.shutdown(),
+        ]).catch(() => undefined);
+        (0, logs_js_1.clearFoamLoggerProvider)();
+        (0, state_js_1.setInitialized)(false);
+        (0, report_js_1.report)({
+            token: options.token,
+            severity: api_logs_1.SeverityNumber.ERROR,
+            message: `SDK initialization failed: ${errorMessage}`,
+            error: errorMessage,
+        });
+    }
+}

package/dist/instrumentations.d.ts

@@ -0,0 +1,4 @@
+import type { Instrumentation } from "@opentelemetry/instrumentation";
+export declare function buildInstrumentations(networkCapture?: "off" | "basic" | "advanced", disableLogSending?: boolean, ignoredOutboundHosts?: readonly string[], additionalInstrumentations?: readonly Instrumentation[]): Instrumentation[];
+export declare const instrumentationName: (instrumentation: Instrumentation) => string;
+export declare const instrumentationLabel: (instrumentation: Instrumentation) => string;

package/dist/instrumentations.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentationLabel = 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 library_versions_js_1 = require("./library-versions.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;
+        }
+    });
+    // When the runtime's http/undici falls outside what the OTel instrumentation
+    // supports, the instrumentation is dropped entirely (enabled: false below
+    // makes getNodeAutoInstrumentations skip it), so the state reports only
+    // instrumentations that can actually work. Foam's capture hooks are also
+    // skipped so nothing patches objects or subscribes to diagnostics channels
+    // that would never fire.
+    const httpCaptureSupported = (0, index_js_1.isHttpCaptureSupported)();
+    const undiciCaptureSupported = (0, index_js_1.isUndiciCaptureSupported)();
+    const bodyHooks = networkCapture === "advanced" && httpCaptureSupported
+        ? (0, index_js_1.createNetworkCaptureHooks)(bodyCaptureEnabled)
+        : undefined;
+    const advancedUndiciHooks = networkCapture === "advanced" && undiciCaptureSupported
+        ? (0, index_js_1.createUndiciNetworkCaptureHooks)(bodyCaptureEnabled)
+        : undefined;
+    const automatic = (0, auto_instrumentations_node_1.getNodeAutoInstrumentations)({
+        "@opentelemetry/instrumentation-bunyan": {
+            disableLogSending: disableLogSending === true,
+        },
+        "@opentelemetry/instrumentation-http": {
+            enabled: httpCaptureSupported,
+            ...(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": {
+            enabled: undiciCaptureSupported,
+            ...(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;
+// State label: "pg@8.11.3" when the target library's version is detectable,
+// otherwise just the short name.
+const instrumentationLabel = (instrumentation) => {
+    const name = (0, exports.instrumentationName)(instrumentation);
+    const version = (0, library_versions_js_1.instrumentedLibraryVersion)(name);
+    return version === undefined ? name : `${name}@${version}`;
+};
+exports.instrumentationLabel = instrumentationLabel;

package/dist/library-versions.d.ts

@@ -0,0 +1 @@
+export declare function instrumentedLibraryVersion(shortName: string): string | undefined;

package/dist/library-versions.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentedLibraryVersion = instrumentedLibraryVersion;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const utils_js_1 = require("./utils.js");
+// Resolves the version of the library an instrumentation targets, so the
+// reported state shows what is actually installed (e.g. "pg@8.11.3"), not
+// just that an instrumentation was registered.
+// Instrumentations of Node built-ins or the runtime itself: the version that
+// matters is the runtime's.
+const RUNTIME_TARGETS = {
+    http: process.versions.node,
+    dns: process.versions.node,
+    net: process.versions.node,
+    console: process.versions.node,
+    "runtime-node": process.versions.node,
+    undici: process.versions.undici,
+    "aws-lambda": undefined, // targets the Lambda environment, not a package
+};
+// Instrumentation short names whose target package is named differently.
+const PACKAGE_NAMES = {
+    cucumber: "@cucumber/cucumber",
+    grpc: "@grpc/grpc-js",
+    hapi: "@hapi/hapi",
+    "nestjs-core": "@nestjs/core",
+};
+// Resolves the package entry point and walks up to its manifest; resolving
+// "<name>/package.json" directly fails for packages whose "exports" field
+// does not expose it (undici, for example).
+function installedPackageVersion(name) {
+    return (0, utils_js_1.safely)(() => {
+        const require = (0, node_module_1.createRequire)(__filename);
+        let directory = (0, node_path_1.dirname)(require.resolve(name));
+        for (;;) {
+            const manifest = (0, utils_js_1.safely)(() => {
+                const parsed = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(directory, "package.json"), "utf8"));
+                return parsed;
+            }, undefined);
+            if (manifest?.name === name && typeof manifest.version === "string") {
+                return manifest.version;
+            }
+            const parent = (0, node_path_1.dirname)(directory);
+            if (parent === directory)
+                return undefined;
+            directory = parent;
+        }
+    }, undefined);
+}
+// Takes the instrumentation short name ("pg", "http", ...) as produced by
+// instrumentationName(); returns undefined when no version is determinable.
+function instrumentedLibraryVersion(shortName) {
+    // Own-property check: `in` would match inherited keys like "toString".
+    if (Object.prototype.hasOwnProperty.call(RUNTIME_TARGETS, shortName)) {
+        return RUNTIME_TARGETS[shortName];
+    }
+    return installedPackageVersion(PACKAGE_NAMES[shortName] ?? shortName);
+}

package/dist/logs.d.ts

@@ -0,0 +1,10 @@
+import type { Attributes } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { type FoamExporterOptions } from "./exporters.js";
+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, options?: FoamExporterOptions): 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, options) {
+    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, options),
+            }),
+        ],
+    });
+    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;
+}