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

package/dist/network-capture/http.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNetworkCaptureHooks = createNetworkCaptureHooks;
+const node_events_1 = require("node:events");
+const utils_js_1 = require("../utils.js");
+const collector_js_1 = require("./collector.js");
+function incomingHeaders(message) {
+    return message.headers;
+}
+function outgoingHeaders(message, direct) {
+    return {
+        ...Object.fromEntries(direct),
+        ...message.getHeaders(),
+    };
+}
+function observeDirectHeaders(args, headers) {
+    const append = (rawKey, value) => {
+        const key = String(rawKey).toLowerCase();
+        const existing = headers.get(key);
+        if (existing === undefined)
+            headers.set(key, value);
+        else if (Array.isArray(existing))
+            existing.push(value);
+        else
+            headers.set(key, [existing, value]);
+    };
+    const candidate = args.length >= 3 && typeof args[1] === "string" ? args[2] : args[1];
+    if (!candidate || typeof candidate !== "object")
+        return;
+    if (Array.isArray(candidate)) {
+        if (candidate.every(Array.isArray)) {
+            for (const entry of candidate) {
+                if (entry.length >= 2) {
+                    append(entry[0], entry[1]);
+                }
+            }
+        }
+        else {
+            for (let index = 0; index + 1 < candidate.length; index += 2) {
+                append(candidate[index], candidate[index + 1]);
+            }
+        }
+        return;
+    }
+    for (const [rawKey, value] of Object.entries(candidate)) {
+        append(rawKey, value);
+    }
+}
+// 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);
+    target[key] = wrapped;
+    return () => {
+        if (target[key] === wrapped)
+            target[key] = original;
+    };
+}
+// Wraps writeHead (when present) to record inline headers; returns an undo.
+function swapWriteHead(target, directHeaders, afterWriteHead) {
+    const original = target.writeHead;
+    if (!original)
+        return () => { };
+    const wrapped = function (...args) {
+        const result = Reflect.apply(original, this, args);
+        (0, utils_js_1.safely)(() => {
+            observeDirectHeaders(args, directHeaders);
+            afterWriteHead?.();
+        });
+        return result;
+    };
+    target.writeHead = wrapped;
+    return () => {
+        if (target.writeHead === wrapped)
+            target.writeHead = original;
+    };
+}
+// 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);
+    return () => {
+        for (const [event, listener] of listeners) {
+            target.removeListener(event, listener);
+        }
+    };
+}
+function observeWritableHeaders(message, span, direction, directHeaders) {
+    const target = message;
+    const applyHeaders = () => {
+        (0, collector_js_1.setHeaderAttributes)(span, direction, outgoingHeaders(message, directHeaders));
+    };
+    const restoreEnd = swapMethod(target, "end", (originalEnd) => function (...args) {
+        const result = Reflect.apply(originalEnd, this, args);
+        (0, utils_js_1.safely)(applyHeaders);
+        return result;
+    });
+    const restoreWriteHead = swapWriteHead(target, directHeaders, applyHeaders);
+    let removeListeners = () => { };
+    // 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],
+    ]);
+}
+function observeReadable(message, collector) {
+    const target = message;
+    const restorePush = swapMethod(target, "push", (originalPush) => function (...args) {
+        // The parser's delivery path runs first and its result is returned
+        // unconditionally; observation failures must never disturb it.
+        const result = Reflect.apply(originalPush, this, args);
+        (0, utils_js_1.safely)(() => {
+            if (args[0] !== null)
+                collector.observe(args[0], args[1]);
+            else
+                collector.finalize(true);
+        });
+        return result;
+    });
+    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],
+        ["close", onIncomplete],
+        [node_events_1.errorMonitor, onIncomplete],
+    ]);
+    collector.addCleanup(() => {
+        restorePush();
+        removeListeners();
+    });
+}
+function observeWritable(message, collector, directHeaders) {
+    const target = message;
+    // Prevents double-observing a final chunk that end() forwards to write() internally.
+    let ending = false;
+    const restoreWrite = swapMethod(target, "write", (originalWrite) => function (...args) {
+        const result = Reflect.apply(originalWrite, this, args);
+        if (!ending)
+            (0, utils_js_1.safely)(() => collector.observe(args[0], args[1]));
+        return result;
+    });
+    const restoreEnd = swapMethod(target, "end", (originalEnd) => function (...args) {
+        ending = true;
+        try {
+            const result = Reflect.apply(originalEnd, this, args);
+            (0, utils_js_1.safely)(() => collector.observe(args[0], args[1]));
+            return result;
+        }
+        finally {
+            ending = false;
+        }
+    });
+    const restoreWriteHead = swapWriteHead(target, directHeaders);
+    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],
+        [node_events_1.errorMonitor, onIncomplete],
+    ]);
+    collector.addCleanup(() => {
+        restoreWrite();
+        restoreEnd();
+        restoreWriteHead();
+        removeListeners();
+    });
+}
+// 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) {
+    // pcga11: Duck-type: only outgoing messages (ClientRequest/ServerResponse) have write/end.
+    if ("write" in message && "end" in message) {
+        const side = direction === "request" ? "client" : "server";
+        const directHeaders = new Map();
+        (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.
+                collector_js_1.BodyCollector.create(span, side, direction, () => outgoingHeaders(message, directHeaders))
+            : undefined;
+        // With a collector, patch write/end/writeHead to copy body chunks as the app sends them.
+        if (collector)
+            observeWritable(message, collector, directHeaders);
+        else if (span.isRecording()) {
+            observeWritableHeaders(message, span, direction, directHeaders);
+        }
+    }
+    else {
+        const side = direction === "request" ? "server" : "client";
+        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;
+        if (collector)
+            observeReadable(message, collector);
+    }
+}
+// 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) {
+            (0, utils_js_1.safely)(() => hookMessage(span, request, "request", bodyCaptureEnabled));
+        },
+        responseHook(span, response) {
+            (0, utils_js_1.safely)(() => hookMessage(span, response, "response", bodyCaptureEnabled));
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+export { createNetworkCaptureHooks } from "./http.js";
+export { createUndiciNetworkCaptureHooks } from "./undici.js";

package/dist/network-capture/index.js

@@ -0,0 +1,17 @@
+"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");
+Object.defineProperty(exports, "createUndiciNetworkCaptureHooks", { enumerable: true, get: function () { return undici_js_1.createUndiciNetworkCaptureHooks; } });

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

@@ -0,0 +1,5 @@
+import type { RequestHookFunction, ResponseHookFunction } from "@opentelemetry/instrumentation-undici";
+export declare function createUndiciNetworkCaptureHooks(bodyCaptureEnabled?: boolean): {
+    requestHook: RequestHookFunction;
+    responseHook: ResponseHookFunction;
+};

package/dist/network-capture/undici.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUndiciNetworkCaptureHooks = createUndiciNetworkCaptureHooks;
+const api_1 = require("@opentelemetry/api");
+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();
+    const existing = headers[name];
+    if (existing === undefined)
+        headers[name] = value;
+    else if (Array.isArray(existing))
+        existing.push(value);
+    else
+        headers[name] = [existing, value];
+}
+function undiciRequestHeaders(value) {
+    const headers = {};
+    if (typeof value === "string") {
+        for (const line of value.split("\r\n")) {
+            const separator = line.indexOf(":");
+            if (separator <= 0)
+                continue;
+            appendHeader(headers, line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+        }
+    }
+    else if (Array.isArray(value)) {
+        for (let index = 0; index + 1 < value.length; index += 2) {
+            appendHeader(headers, value[index], value[index + 1]);
+        }
+    }
+    return headers;
+}
+function undiciResponseHeaders(value) {
+    if (!Array.isArray(value))
+        return {};
+    const headers = {};
+    for (let index = 0; index + 1 < value.length; index += 2) {
+        const name = value[index];
+        const headerValue = value[index + 1];
+        appendHeader(headers, Buffer.isBuffer(name) ? name.toString("latin1") : name, Buffer.isBuffer(headerValue)
+            ? headerValue.toString("latin1")
+            : headerValue);
+    }
+    return headers;
+}
+function undiciRequest(message) {
+    if (!message || typeof message !== "object" || !("request" in message)) {
+        return undefined;
+    }
+    const request = message.request;
+    return request && typeof request === "object"
+        ? request
+        : undefined;
+}
+function undiciCollector(session, direction) {
+    const field = direction === "request" ? "requestBody" : "responseBody";
+    const existing = session[field];
+    if (existing)
+        return existing;
+    const headers = direction === "request" ? session.requestHeaders : session.responseHeaders;
+    if (!headers)
+        return undefined;
+    const created = collector_js_1.BodyCollector.create(session.span, "client", direction, () => headers);
+    if (created)
+        session[field] = created;
+    return created;
+}
+function finishUndici(request, complete) {
+    const session = undiciSessions.get(request);
+    if (!session)
+        return;
+    undiciSessions.delete(request);
+    session.requestBody?.finalize(complete);
+    session.responseBody?.finalize(complete);
+}
+function bindUndiciChannel(name, handle) {
+    (0, node_diagnostics_channel_1.subscribe)(name, (message) => {
+        (0, utils_js_1.safely)(() => {
+            const request = undiciRequest(message);
+            if (!request)
+                return;
+            const session = undiciSessions.get(request);
+            if (!session)
+                return;
+            handle(message, request, session);
+        });
+    });
+}
+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;
+    (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) => {
+        finishUndici(request, true);
+    });
+    bindUndiciChannel("undici:request:error", (_message, request) => {
+        finishUndici(request, false);
+    });
+}
+function createUndiciNetworkCaptureHooks(bodyCaptureEnabled = true) {
+    if (bodyCaptureEnabled)
+        bindUndiciBodyChannels();
+    return {
+        requestHook(span, request) {
+            (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) {
+            (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>;

package/dist/otlp.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendOtlpLog = sendOtlpLog;
+const constants_js_1 = require("./constants.js");
+const endpoint_js_1 = require("./endpoint.js");
+// pcga11: Pipeline-independent OTLP log delivery.
+// Use when the SDK's LoggerProvider/exporter never got set up or is
+// broken (diagnostics). Not a client surface: no batching, no resource
+// detectors, no trace correlation, one fetch per record. Client logs go
+// through the Foam LoggerProvider in logs.ts.
+async function sendOtlpLog({ token, resourceAttributes, scopeName, severityNumber, body, }) {
+    try {
+        await fetch(`${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_LOGS_PATH}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                resourceLogs: [
+                    {
+                        resource: {
+                            attributes: Object.entries(resourceAttributes).map(([key, value]) => ({ key, value: { stringValue: value } })),
+                        },
+                        scopeLogs: [
+                            {
+                                scope: { name: scopeName },
+                                logRecords: [
+                                    {
+                                        timeUnixNano: String(BigInt(Date.now()) * 1000000n),
+                                        severityNumber,
+                                        severityText: constants_js_1.SEVERITY_TEXT[severityNumber],
+                                        body: { stringValue: body },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            }),
+        });
+    }
+    catch {
+        // pcga11: do not remove this catch block. Ingest must never throw into application code.
+    }
+}

package/dist/propagation.d.ts

@@ -0,0 +1,5 @@
+import { type Context } from "@opentelemetry/api";
+export declare function injectTraceContext(carrier: Record<string, string>): void;
+export declare function extractTraceContext(carrier: Record<string, string>): Context;
+export declare const setBaggage: (key: string, value: string) => void;
+export declare function getBaggage(key: string): string | undefined;

package/dist/propagation.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setBaggage = void 0;
+exports.injectTraceContext = injectTraceContext;
+exports.extractTraceContext = extractTraceContext;
+exports.getBaggage = getBaggage;
+const node_async_hooks_1 = require("node:async_hooks");
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const utils_js_1 = require("./utils.js");
+const state_js_1 = require("./state.js");
+// pcga11: Below are some definitios you may find helpful to understand this file.
+// CompositePropagator is a local propagator used on custom transports (Kafka, SQS, Redis, WebSocket)
+// An "injector/extractor" turns the context into headers and vice versa for distributed tracing
+// Carrier is the headers object can be kafka message, queue payload or any other transport headers
+// Context.active() returns the process' context. Think of it like a local RAM for this request in this Node process. Another service, process or even another Kafka in the same service will have a different context.active().
+const propagator = new core_1.CompositePropagator({
+    propagators: [new core_1.W3CTraceContextPropagator(), new core_1.W3CBaggagePropagator()],
+});
+const baggageStorage = new node_async_hooks_1.AsyncLocalStorage();
+function contextWithBaggage() {
+    const entries = Object.fromEntries(api_1.propagation.getBaggage(api_1.context.active())?.getAllEntries() ?? []);
+    for (const [key, value] of baggageStorage.getStore() ?? []) {
+        entries[key] = { value };
+    }
+    const baggage = api_1.propagation.createBaggage(entries);
+    return api_1.propagation.setBaggage(api_1.context.active(), baggage);
+}
+function injectTraceContext(carrier) {
+    (0, utils_js_1.safely)(() => {
+        propagator.inject(contextWithBaggage(), carrier, api_1.defaultTextMapSetter);
+    });
+}
+function extractTraceContext(carrier) {
+    return (0, utils_js_1.safely)(() => propagator.extract(api_1.context.active(), carrier, api_1.defaultTextMapGetter), api_1.context.active());
+}
+exports.setBaggage = (0, utils_js_1.whenInitialized)(state_js_1.Signals.baggage, (key, value) => {
+    const next = new Map(baggageStorage.getStore() ?? []);
+    next.set(key, value);
+    baggageStorage.enterWith(next);
+});
+function getBaggage(key) {
+    return (0, utils_js_1.safely)(() => baggageStorage.getStore()?.get(key) ??
+        api_1.propagation.getBaggage(api_1.context.active())?.getEntry(key)?.value, undefined);
+}

package/dist/report.d.ts

@@ -0,0 +1,9 @@
+import { SeverityNumber } from "@opentelemetry/api-logs";
+export declare function report({ name, environment, token, severity, message, error, }: {
+    name?: string;
+    environment?: string;
+    token?: string;
+    severity: SeverityNumber;
+    message: string;
+    error?: string;
+}): Promise<void>;