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

package/dist/diagnostics.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.warn = exports.info = void 0;
+exports.configureDiagnostics = configureDiagnostics;
+exports.sendStateDiagnosticLog = sendStateDiagnosticLog;
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const constants_js_1 = require("./constants.js");
+const state_js_1 = require("./state.js");
+const logger = api_1.diag.createComponentLogger({ namespace: constants_js_1.FOAM_IDENTIFIER_NAME });
+function configureDiagnostics() {
+    const fromEnv = (0, core_1.diagLogLevelFromString)((0, core_1.getStringFromEnv)(constants_js_1.DIAG_LOG_LEVEL));
+    api_1.diag.setLogger(new api_1.DiagConsoleLogger(), fromEnv ?? api_1.DiagLogLevel.INFO);
+}
+const info = (message) => {
+    logger.info(message);
+};
+exports.info = info;
+const warn = (message) => {
+    logger.warn(message);
+};
+exports.warn = warn;
+const error = (message) => {
+    logger.error(message);
+};
+exports.error = error;
+// pcga11: We send the diagnostic log to Foam's OTLP endpoint directly instead of using the logger provider or exporter to deliver diagnostics.
+// We do not want to rely on the logger provider or exporter to deliver diagnostics. As they themselves may not be instrumented.
+async function sendStateDiagnosticLog({ name, environment, token, tier, severity, error, }) {
+    if (!name?.trim() || !environment?.trim() || !token) {
+        return;
+    }
+    try {
+        await fetch(`${constants_js_1.FOAM_ENDPOINT}${constants_js_1.FOAM_OTLP_LOGS_PATH}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                resourceLogs: [
+                    {
+                        resource: {
+                            attributes: [
+                                { key: semantic_conventions_1.ATTR_SERVICE_NAME, value: { stringValue: name } },
+                                {
+                                    key: semantic_conventions_1.ATTR_DEPLOYMENT_ENVIRONMENT_NAME,
+                                    value: { stringValue: environment },
+                                },
+                                { key: constants_js_1.FOAM_INGEST_TIER, value: { stringValue: tier } },
+                            ],
+                        },
+                        scopeLogs: [
+                            {
+                                scope: { name: constants_js_1.FOAM_IDENTIFIER_NAME },
+                                logRecords: [
+                                    {
+                                        timeUnixNano: String(BigInt(Date.now()) * 1000000n),
+                                        severityNumber: severity,
+                                        severityText: constants_js_1.SEVERITY_TEXT[severity],
+                                        body: {
+                                            stringValue: JSON.stringify({
+                                                ...(0, state_js_1.getState)(),
+                                                [constants_js_1.FOAM_INGEST_TIER]: tier,
+                                                ...(error === undefined
+                                                    ? {}
+                                                    : { error }),
+                                            }),
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            }),
+        });
+    }
+    catch {
+        // pcga11: do not remove this catch block. Ingest must never throw into application code.
+    }
+}

package/dist/exporters.d.ts

@@ -0,0 +1,25 @@
+import type { Attributes } from "@opentelemetry/api";
+import type { ExportResult } from "@opentelemetry/core";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import type { ReadableLogRecord } from "@opentelemetry/sdk-logs";
+import type { ResourceMetrics } from "@opentelemetry/sdk-metrics";
+import type { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+type Stamp = Attributes | undefined;
+export declare class FoamTraceExporter extends OTLPTraceExporter {
+    private readonly stamp?;
+    constructor(token: string, stamp?: Stamp);
+    export(spans: ReadableSpan[], callback: (result: ExportResult) => void): void;
+}
+export declare class FoamLogExporter extends OTLPLogExporter {
+    private readonly stamp?;
+    constructor(token: string, stamp?: Stamp);
+    export(records: ReadableLogRecord[], callback: (result: ExportResult) => void): void;
+}
+export declare class FoamMetricExporter extends OTLPMetricExporter {
+    private readonly stamp?;
+    constructor(token: string, stamp?: Stamp);
+    export(resourceMetrics: ResourceMetrics, callback: (result: ExportResult) => void): void;
+}
+export {};

package/dist/exporters.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoamMetricExporter = exports.FoamLogExporter = exports.FoamTraceExporter = void 0;
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const constants_js_1 = require("./constants.js");
+class FoamTraceExporter extends exporter_trace_otlp_http_1.OTLPTraceExporter {
+    stamp;
+    constructor(token, stamp) {
+        super({
+            url: `${constants_js_1.FOAM_ENDPOINT}${constants_js_1.FOAM_OTLP_TRACES_PATH}`,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.stamp = stamp;
+    }
+    export(spans, callback) {
+        const { stamp } = this;
+        if (!stamp) {
+            super.export(spans, callback);
+            return;
+        }
+        const overlay = (0, resources_1.resourceFromAttributes)(stamp);
+        // Stamped copies never mutate the application's own telemetry objects.
+        // a shallow copy of each span so Foam can stamp the resource without mutating the original
+        const copies = spans.map((span) => ({
+            name: span.name,
+            kind: span.kind,
+            // SpanContext is a function so we need to bind it to the original span so we do not lose the context
+            spanContext: span.spanContext.bind(span),
+            parentSpanContext: span.parentSpanContext,
+            startTime: span.startTime,
+            endTime: span.endTime,
+            status: span.status,
+            attributes: span.attributes,
+            links: span.links,
+            events: span.events,
+            duration: span.duration,
+            ended: span.ended,
+            resource: span.resource.merge(overlay),
+            instrumentationScope: span.instrumentationScope,
+            droppedAttributesCount: span.droppedAttributesCount,
+            droppedEventsCount: span.droppedEventsCount,
+            droppedLinksCount: span.droppedLinksCount,
+        }));
+        super.export(copies, callback);
+    }
+}
+exports.FoamTraceExporter = FoamTraceExporter;
+class FoamLogExporter extends exporter_logs_otlp_http_1.OTLPLogExporter {
+    stamp;
+    constructor(token, stamp) {
+        super({
+            url: `${constants_js_1.FOAM_ENDPOINT}${constants_js_1.FOAM_OTLP_LOGS_PATH}`,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.stamp = stamp;
+    }
+    export(records, callback) {
+        const { stamp } = this;
+        if (!stamp) {
+            super.export(records, callback);
+            return;
+        }
+        const overlay = (0, resources_1.resourceFromAttributes)(stamp);
+        const copies = records.map((record) => ({
+            hrTime: record.hrTime,
+            hrTimeObserved: record.hrTimeObserved,
+            spanContext: record.spanContext,
+            severityText: record.severityText,
+            severityNumber: record.severityNumber,
+            body: record.body,
+            eventName: record.eventName,
+            resource: record.resource.merge(overlay),
+            instrumentationScope: record.instrumentationScope,
+            attributes: record.attributes,
+            droppedAttributesCount: record.droppedAttributesCount,
+        }));
+        super.export(copies, callback);
+    }
+}
+exports.FoamLogExporter = FoamLogExporter;
+class FoamMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporter {
+    stamp;
+    constructor(token, stamp) {
+        super({
+            url: `${constants_js_1.FOAM_ENDPOINT}${constants_js_1.FOAM_OTLP_METRICS_PATH}`,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.stamp = stamp;
+    }
+    export(resourceMetrics, callback) {
+        const { stamp } = this;
+        if (!stamp) {
+            super.export(resourceMetrics, callback);
+            return;
+        }
+        super.export({
+            ...resourceMetrics,
+            resource: resourceMetrics.resource.merge((0, resources_1.resourceFromAttributes)(stamp)),
+        }, callback);
+    }
+}
+exports.FoamMetricExporter = FoamMetricExporter;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { init } from "./init.js";
+export { getState } from "./state.js";
+export { createFoamIngestLogRecordProcessor, createFoamIngestMetricReader, createFoamIngestSpanProcessor, } from "./ingest.js";
+export { extractTraceContext, getBaggage, injectTraceContext, setBaggage, } from "./propagation.js";
+export { addUpDownCounter, incrementCounter, recordHistogram, setMetric, } from "./metrics.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMetric = exports.recordHistogram = exports.incrementCounter = exports.addUpDownCounter = exports.setBaggage = exports.injectTraceContext = exports.getBaggage = exports.extractTraceContext = exports.createFoamIngestSpanProcessor = exports.createFoamIngestMetricReader = exports.createFoamIngestLogRecordProcessor = exports.getState = exports.init = void 0;
+var init_js_1 = require("./init.js");
+Object.defineProperty(exports, "init", { enumerable: true, get: function () { return init_js_1.init; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "getState", { enumerable: true, get: function () { return state_js_1.getState; } });
+var ingest_js_1 = require("./ingest.js");
+Object.defineProperty(exports, "createFoamIngestLogRecordProcessor", { enumerable: true, get: function () { return ingest_js_1.createFoamIngestLogRecordProcessor; } });
+Object.defineProperty(exports, "createFoamIngestMetricReader", { enumerable: true, get: function () { return ingest_js_1.createFoamIngestMetricReader; } });
+Object.defineProperty(exports, "createFoamIngestSpanProcessor", { enumerable: true, get: function () { return ingest_js_1.createFoamIngestSpanProcessor; } });
+var propagation_js_1 = require("./propagation.js");
+Object.defineProperty(exports, "extractTraceContext", { enumerable: true, get: function () { return propagation_js_1.extractTraceContext; } });
+Object.defineProperty(exports, "getBaggage", { enumerable: true, get: function () { return propagation_js_1.getBaggage; } });
+Object.defineProperty(exports, "injectTraceContext", { enumerable: true, get: function () { return propagation_js_1.injectTraceContext; } });
+Object.defineProperty(exports, "setBaggage", { enumerable: true, get: function () { return propagation_js_1.setBaggage; } });
+var metrics_js_1 = require("./metrics.js");
+Object.defineProperty(exports, "addUpDownCounter", { enumerable: true, get: function () { return metrics_js_1.addUpDownCounter; } });
+Object.defineProperty(exports, "incrementCounter", { enumerable: true, get: function () { return metrics_js_1.incrementCounter; } });
+Object.defineProperty(exports, "recordHistogram", { enumerable: true, get: function () { return metrics_js_1.recordHistogram; } });
+Object.defineProperty(exports, "setMetric", { enumerable: true, get: function () { return metrics_js_1.setMetric; } });

package/dist/ingest.d.ts

@@ -0,0 +1,6 @@
+import { type LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
+export declare function createFoamIngestSpanProcessor(name: string, environment: string, token: string): SpanProcessor;
+export declare function createFoamIngestLogRecordProcessor(name: string, environment: string, token: string): LogRecordProcessor;
+export declare function createFoamIngestMetricReader(name: string, environment: string, token: string): PeriodicExportingMetricReader;

package/dist/ingest.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFoamIngestSpanProcessor = createFoamIngestSpanProcessor;
+exports.createFoamIngestLogRecordProcessor = createFoamIngestLogRecordProcessor;
+exports.createFoamIngestMetricReader = createFoamIngestMetricReader;
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+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 api_logs_1 = require("@opentelemetry/api-logs");
+const constants_js_1 = require("./constants.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const exporters_js_1 = require("./exporters.js");
+const state_js_1 = require("./state.js");
+function prepareStamp(name, environment, token) {
+    if (!name?.trim() || !environment?.trim() || !token) {
+        throw new Error(`${constants_js_1.FOAM_IDENTIFIER_NAME}: name, environment, and token are required`);
+    }
+    return {
+        stamp: {
+            [semantic_conventions_1.ATTR_SERVICE_NAME]: name,
+            [semantic_conventions_1.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: environment,
+            [constants_js_1.FOAM_INGEST_TIER]: "external",
+        },
+    };
+}
+function claimIngestSignal(signal, name, environment, token) {
+    (0, state_js_1.setSignal)(signal, true);
+    void (0, diagnostics_js_1.sendStateDiagnosticLog)({
+        name,
+        environment,
+        token,
+        tier: "external",
+        severity: api_logs_1.SeverityNumber.INFO,
+    });
+}
+function createFoamIngestSpanProcessor(name, environment, token) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const processor = new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(token, stamp));
+    claimIngestSignal(state_js_1.Signals.traces, name, environment, token);
+    return processor;
+}
+function createFoamIngestLogRecordProcessor(name, environment, token) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const processor = new sdk_logs_1.BatchLogRecordProcessor({
+        exporter: new exporters_js_1.FoamLogExporter(token, stamp),
+    });
+    claimIngestSignal(state_js_1.Signals.logs, name, environment, token);
+    return processor;
+}
+function createFoamIngestMetricReader(name, environment, token) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const reader = new sdk_metrics_1.PeriodicExportingMetricReader({
+        exporter: new exporters_js_1.FoamMetricExporter(token, stamp),
+    });
+    claimIngestSignal(state_js_1.Signals.metrics, name, environment, token);
+    return reader;
+}

package/dist/init.d.ts

@@ -0,0 +1,22 @@
+import { type Attributes } from "@opentelemetry/api";
+import { type Instrumentation } from "@opentelemetry/instrumentation";
+import { type LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { type MetricReader } from "@opentelemetry/sdk-metrics";
+import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
+export declare function init({ sampleRate, disableLogSending, networkCapture, // pcga11: We do not default to advanced because this is something our clients approve to opt in during onboarding.
+enabled, ...options }: {
+    name: string;
+    environment: string;
+    token?: string;
+    version?: string;
+    sampleRate?: number;
+    disableLogSending?: boolean;
+    networkCapture?: "off" | "basic" | "advanced";
+    enabled?: boolean;
+    additionalInstrumentations?: readonly Instrumentation[];
+    additionalSpanProcessors?: readonly SpanProcessor[];
+    additionalLogRecordProcessors?: readonly LogRecordProcessor[];
+    additionalMetricReaders?: readonly MetricReader[];
+    additionalResourceAttributes?: Attributes;
+    ignoredOutboundHosts?: readonly string[];
+}): void;

package/dist/init.js

@@ -0,0 +1,121 @@
+"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 constants_js_1 = require("./constants.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const exporters_js_1 = require("./exporters.js");
+const instrumentations_js_1 = require("./instrumentations.js");
+const state_js_1 = require("./state.js");
+// TODO(pcga11): redact and beforeSend as well as conflicts handling not yet implemented.
+function init({ sampleRate = 1, disableLogSending = false, networkCapture = "basic", // pcga11: We do not default to advanced because this is something our clients approve to opt in during onboarding.
+enabled = true, ...options }) {
+    if (!enabled) {
+        (0, diagnostics_js_1.info)("Foam SDK for Node.js is disabled");
+        return;
+    }
+    if ((0, state_js_1.getInitialized)()) {
+        (0, diagnostics_js_1.warn)("Foam SDK for Node.js is already initialized");
+        return;
+    }
+    (0, diagnostics_js_1.configureDiagnostics)();
+    if (!options.name?.trim() || !options.environment?.trim() || !options.token) {
+        (0, diagnostics_js_1.error)(`${constants_js_1.FOAM_IDENTIFIER_NAME}: name, environment, and token are required`);
+        return;
+    }
+    try {
+        const resource = (0, resource_js_1.createFoamResource)(options.name, options.environment, options.version, options.additionalResourceAttributes);
+        // pcga11: Register our context manager and propagator; if another SDK already
+        // registered one, keep theirs
+        // TODO(pcga11): Implement a way to handle piggy backing the context manager and propagator from another SDK.
+        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(),
+            ],
+        })));
+        // 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.
+        const 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)),
+                ...(options.additionalSpanProcessors ?? []),
+            ],
+        });
+        const meterProvider = new sdk_metrics_1.MeterProvider({
+            resource,
+            readers: [
+                new sdk_metrics_1.PeriodicExportingMetricReader({
+                    exporter: new exporters_js_1.FoamMetricExporter(options.token),
+                }),
+                ...(options.additionalMetricReaders ?? []),
+            ],
+        });
+        const loggerProvider = new sdk_logs_1.LoggerProvider({
+            resource,
+            processors: [
+                new sdk_logs_1.BatchLogRecordProcessor({
+                    exporter: new exporters_js_1.FoamLogExporter(options.token),
+                }),
+                ...(options.additionalLogRecordProcessors ?? []),
+            ],
+        });
+        // 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 mark ownership.
+        (0, state_js_1.setSignal)(state_js_1.Signals.traces, api_1.trace.setGlobalTracerProvider(tracerProvider));
+        (0, state_js_1.setSignal)(state_js_1.Signals.metrics, api_1.metrics.setGlobalMeterProvider(meterProvider));
+        (0, state_js_1.setSignal)(state_js_1.Signals.logs, api_logs_1.logs.setGlobalLoggerProvider(loggerProvider) === loggerProvider);
+        const instrumentations = (0, instrumentations_js_1.buildInstrumentations)(networkCapture, disableLogSending, options.ignoredOutboundHosts, options.additionalInstrumentations ?? []);
+        (0, instrumentation_1.registerInstrumentations)({ instrumentations });
+        (0, state_js_1.setInstrumentations)(instrumentations.map(instrumentations_js_1.instrumentationName));
+        // pcga11: Signals are flushed, remaining batches are sent, and exporters are stopped before the process exits.
+        process.once("beforeExit", () => {
+            void Promise.all([
+                (0, state_js_1.getSignal)(state_js_1.Signals.traces) ? tracerProvider.shutdown() : undefined,
+                (0, state_js_1.getSignal)(state_js_1.Signals.metrics) ? meterProvider.shutdown() : undefined,
+                (0, state_js_1.getSignal)(state_js_1.Signals.logs) ? loggerProvider.shutdown() : undefined,
+            ]).catch(() => undefined);
+        });
+        (0, state_js_1.setInitialized)(true);
+        (0, diagnostics_js_1.info)("Foam SDK for Node.js initialized");
+        void (0, diagnostics_js_1.sendStateDiagnosticLog)({
+            name: options.name,
+            environment: options.environment,
+            token: options.token,
+            tier: "internal",
+            severity: api_logs_1.SeverityNumber.INFO,
+        });
+    }
+    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, false);
+        }
+        (0, state_js_1.setInitialized)(false);
+        (0, diagnostics_js_1.error)(`Foam SDK for Node.js initialization failed: ${errorMessage}`);
+        void (0, diagnostics_js_1.sendStateDiagnosticLog)({
+            name: options.name,
+            environment: options.environment,
+            token: options.token,
+            tier: "internal",
+            severity: api_logs_1.SeverityNumber.ERROR,
+            error: errorMessage,
+        });
+    }
+}

package/dist/instrumentations.d.ts

@@ -0,0 +1,3 @@
+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;

package/dist/instrumentations.js

@@ -0,0 +1,79 @@
+"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 state_js_1 = require("./state.js");
+const constants_js_1 = require("./constants.js");
+function buildInstrumentations(networkCapture = "basic", disableLogSending = false, ignoredOutboundHosts, additionalInstrumentations) {
+    const bodyCaptureEnabled = (0, state_js_1.getSignal)(state_js_1.Signals.logs);
+    const capturedHeaders = networkCapture === "off" ? undefined : [...constants_js_1.SAFE_NETWORK_HEADERS];
+    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: ((request) => typeof request.hostname === "string" &&
+                (ignoredOutboundHosts ?? []).includes(request.hostname)),
+        },
+        "@opentelemetry/instrumentation-openai": {
+            captureMessageContent: networkCapture === "advanced",
+        },
+        "@opentelemetry/instrumentation-pino": {
+            disableLogSending: disableLogSending === true,
+        },
+        "@opentelemetry/instrumentation-undici": {
+            ...(capturedHeaders
+                ? {
+                    headersToSpanAttributes: {
+                        requestHeaders: capturedHeaders,
+                        responseHeaders: capturedHeaders,
+                    },
+                }
+                : {}),
+            ...(advancedUndiciHooks ?? {}),
+        },
+        "@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/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;
+}