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

package/dist/before-send.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBeforeSend = resolveBeforeSend;
+exports.invokeBeforeSend = invokeBeforeSend;
+function resolveBeforeSend(hook) {
+    if (hook === undefined || hook === null)
+        return undefined;
+    if (typeof hook !== "function") {
+        throw new TypeError("[foam] beforeSend must be a function");
+    }
+    return hook;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isEvent(value, expectedType) {
+    if (!isRecord(value) || value.type !== expectedType || !isRecord(value.attributes)) {
+        return false;
+    }
+    if (expectedType === "span") {
+        return (typeof value.name === "string" &&
+            Array.isArray(value.events) &&
+            value.events.every((entry) => isRecord(entry) && typeof entry.name === "string") &&
+            Array.isArray(value.links) &&
+            value.links.every((entry) => isRecord(entry) && isRecord(entry.context)));
+    }
+    return value.severityText === undefined || typeof value.severityText === "string";
+}
+function invokeBeforeSend(hook, event) {
+    let copy;
+    try {
+        copy = structuredClone(event);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const result = hook(copy);
+        if (result === null)
+            return null;
+        return isEvent(result, event.type) ? result : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,44 @@
+import { SeverityNumber } from "@opentelemetry/api-logs";
+export declare const FOAM_ENDPOINT = "https://otel.api.foam.ai";
+export declare const FOAM_INGEST_HOST: string;
+export declare const ATTR_FOAM_INGEST_HOST = "foam.ingest.host";
+export declare const FOAM_IDENTIFIER_NAME = "[foam-otel]";
+export declare const FOAM_DISTRO_NAME = "@foam-ai/node";
+export declare const FOAM_DISTRO_VERSION = "0.1.0-alpha.11";
+export declare const FOAM_OTLP_TRACES_PATH = "/v1/traces";
+export declare const FOAM_OTLP_LOGS_PATH = "/v1/logs";
+export declare const FOAM_OTLP_METRICS_PATH = "/v1/metrics";
+export declare const NETWORK_BODY_CHUNK_BYTES: number;
+export declare const NETWORK_BODY_MAX_CAPTURE_BYTES: number;
+export declare const NETWORK_BODY_MAX_DECODE_BYTES: number;
+export declare const NETWORK_CAPTURE_EVENT = "foam.http.body.chunk";
+export declare const NETWORK_CAPTURE_EVENT_BODY = "HTTP body chunk";
+export declare const NETWORK_CAPTURE_DEADLINE_MS = 60000;
+export declare const MAX_ACTIVE_CAPTURES = 128;
+export declare const ATTR_HTTP_REQUEST_BODY_SIZE = "http.request.body.size";
+export declare const ATTR_HTTP_RESPONSE_BODY_SIZE = "http.response.body.size";
+export declare const ATTR_HTTP_REQUEST_BODY_CONTENT = "http.request.body.content";
+export declare const ATTR_HTTP_RESPONSE_BODY_CONTENT = "http.response.body.content";
+export declare const ATTR_FOAM_HTTP_BODY_ID = "foam.http.body.id";
+export declare const ATTR_FOAM_HTTP_BODY_SIDE = "foam.http.body.side";
+export declare const ATTR_FOAM_HTTP_BODY_DIRECTION = "foam.http.body.direction";
+export declare const ATTR_FOAM_HTTP_BODY_COMPLETE = "foam.http.body.complete";
+export declare const ATTR_FOAM_HTTP_BODY_TRUNCATED = "foam.http.body.truncated";
+export declare const ATTR_FOAM_HTTP_BODY_OUTCOME = "foam.http.body.outcome";
+export declare const ATTR_FOAM_HTTP_BODY_CAPTURED_BYTES = "foam.http.body.captured_bytes";
+export declare const ATTR_FOAM_HTTP_BODY_CHUNK_COUNT = "foam.http.body.chunk.count";
+export declare const ATTR_FOAM_HTTP_BODY_CHUNK_INDEX = "foam.http.body.chunk.index";
+export declare const ATTR_FOAM_HTTP_BODY_CHUNK_BYTES = "foam.http.body.chunk.bytes";
+export declare const ATTR_FOAM_HTTP_BODY_CHUNK_CONTENT = "foam.http.body.chunk.content";
+export declare const ATTR_FOAM_HTTP_REQUEST_BODY_CAPTURE_ID = "foam.http.request.body.capture_id";
+export declare const ATTR_FOAM_HTTP_RESPONSE_BODY_CAPTURE_ID = "foam.http.response.body.capture_id";
+export declare const ATTR_FOAM_HTTP_REQUEST_BODY_COMPLETE = "foam.http.request.body.complete";
+export declare const ATTR_FOAM_HTTP_RESPONSE_BODY_COMPLETE = "foam.http.response.body.complete";
+export declare const ATTR_FOAM_HTTP_REQUEST_BODY_TRUNCATED = "foam.http.request.body.truncated";
+export declare const ATTR_FOAM_HTTP_RESPONSE_BODY_TRUNCATED = "foam.http.response.body.truncated";
+export declare const SAFE_NETWORK_HEADERS: readonly ["content-type", "content-length", "content-encoding"];
+export declare const REDACTED_VALUE = "[REDACTED]";
+export declare const FULL_MASK = "********";
+export declare const TAIL_MASK_THRESHOLD = 12;
+export declare const DIAG_LOG_LEVEL = "OTEL_LOG_LEVEL";
+export declare const SEVERITY_TEXT: Partial<Record<SeverityNumber, string>>;

package/dist/constants.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEVERITY_TEXT = exports.DIAG_LOG_LEVEL = exports.TAIL_MASK_THRESHOLD = exports.FULL_MASK = exports.REDACTED_VALUE = exports.SAFE_NETWORK_HEADERS = exports.ATTR_FOAM_HTTP_RESPONSE_BODY_TRUNCATED = exports.ATTR_FOAM_HTTP_REQUEST_BODY_TRUNCATED = exports.ATTR_FOAM_HTTP_RESPONSE_BODY_COMPLETE = exports.ATTR_FOAM_HTTP_REQUEST_BODY_COMPLETE = exports.ATTR_FOAM_HTTP_RESPONSE_BODY_CAPTURE_ID = exports.ATTR_FOAM_HTTP_REQUEST_BODY_CAPTURE_ID = exports.ATTR_FOAM_HTTP_BODY_CHUNK_CONTENT = exports.ATTR_FOAM_HTTP_BODY_CHUNK_BYTES = exports.ATTR_FOAM_HTTP_BODY_CHUNK_INDEX = exports.ATTR_FOAM_HTTP_BODY_CHUNK_COUNT = exports.ATTR_FOAM_HTTP_BODY_CAPTURED_BYTES = exports.ATTR_FOAM_HTTP_BODY_OUTCOME = exports.ATTR_FOAM_HTTP_BODY_TRUNCATED = exports.ATTR_FOAM_HTTP_BODY_COMPLETE = exports.ATTR_FOAM_HTTP_BODY_DIRECTION = exports.ATTR_FOAM_HTTP_BODY_SIDE = exports.ATTR_FOAM_HTTP_BODY_ID = exports.ATTR_HTTP_RESPONSE_BODY_CONTENT = exports.ATTR_HTTP_REQUEST_BODY_CONTENT = exports.ATTR_HTTP_RESPONSE_BODY_SIZE = exports.ATTR_HTTP_REQUEST_BODY_SIZE = exports.MAX_ACTIVE_CAPTURES = exports.NETWORK_CAPTURE_DEADLINE_MS = exports.NETWORK_CAPTURE_EVENT_BODY = exports.NETWORK_CAPTURE_EVENT = exports.NETWORK_BODY_MAX_DECODE_BYTES = exports.NETWORK_BODY_MAX_CAPTURE_BYTES = exports.NETWORK_BODY_CHUNK_BYTES = exports.FOAM_OTLP_METRICS_PATH = exports.FOAM_OTLP_LOGS_PATH = exports.FOAM_OTLP_TRACES_PATH = exports.FOAM_DISTRO_VERSION = exports.FOAM_DISTRO_NAME = exports.FOAM_IDENTIFIER_NAME = exports.ATTR_FOAM_INGEST_HOST = exports.FOAM_INGEST_HOST = exports.FOAM_ENDPOINT = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+exports.FOAM_ENDPOINT = "https://otel.api.foam.ai";
+exports.FOAM_INGEST_HOST = new URL(exports.FOAM_ENDPOINT).hostname;
+exports.ATTR_FOAM_INGEST_HOST = "foam.ingest.host";
+exports.FOAM_IDENTIFIER_NAME = "[foam-otel]";
+exports.FOAM_DISTRO_NAME = "@foam-ai/node";
+exports.FOAM_DISTRO_VERSION = "0.1.0-alpha.11";
+exports.FOAM_OTLP_TRACES_PATH = "/v1/traces";
+exports.FOAM_OTLP_LOGS_PATH = "/v1/logs";
+exports.FOAM_OTLP_METRICS_PATH = "/v1/metrics";
+exports.NETWORK_BODY_CHUNK_BYTES = 64 * 1024; // pcga11: 64Kib
+exports.NETWORK_BODY_MAX_CAPTURE_BYTES = 1024 * 1024; // pcga11: 1Mib
+// Bounds sync zlib output when decoding captured bodies. 1 MiB of captured
+// gzip can legally inflate to ~1 GiB (worst case ~1032:1), which would be
+// allocated synchronously on the event loop and could OOM-abort the host
+// app. Past this bound zlib throws instead, and the capture falls back to
+// the compressed wire bytes. 16x covers typical text compression ratios.
+exports.NETWORK_BODY_MAX_DECODE_BYTES = 16 * exports.NETWORK_BODY_MAX_CAPTURE_BYTES;
+exports.NETWORK_CAPTURE_EVENT = "foam.http.body.chunk";
+exports.NETWORK_CAPTURE_EVENT_BODY = "HTTP body chunk";
+exports.NETWORK_CAPTURE_DEADLINE_MS = 60_000;
+exports.MAX_ACTIVE_CAPTURES = 128;
+// pcga11: Do not change these.
+// Spec names copied from OpenTelemetry HTTP semantic conventions. 1.43.0 does
+// not export BODY_CONTENT, and OTel JS recommends copying unstable names
+// instead of importing `@opentelemetry/semantic-conventions/incubating`.
+exports.ATTR_HTTP_REQUEST_BODY_SIZE = "http.request.body.size";
+exports.ATTR_HTTP_RESPONSE_BODY_SIZE = "http.response.body.size";
+exports.ATTR_HTTP_REQUEST_BODY_CONTENT = "http.request.body.content";
+exports.ATTR_HTTP_RESPONSE_BODY_CONTENT = "http.response.body.content";
+exports.ATTR_FOAM_HTTP_BODY_ID = "foam.http.body.id";
+exports.ATTR_FOAM_HTTP_BODY_SIDE = "foam.http.body.side";
+exports.ATTR_FOAM_HTTP_BODY_DIRECTION = "foam.http.body.direction";
+exports.ATTR_FOAM_HTTP_BODY_COMPLETE = "foam.http.body.complete";
+exports.ATTR_FOAM_HTTP_BODY_TRUNCATED = "foam.http.body.truncated";
+exports.ATTR_FOAM_HTTP_BODY_OUTCOME = "foam.http.body.outcome";
+exports.ATTR_FOAM_HTTP_BODY_CAPTURED_BYTES = "foam.http.body.captured_bytes";
+exports.ATTR_FOAM_HTTP_BODY_CHUNK_COUNT = "foam.http.body.chunk.count";
+exports.ATTR_FOAM_HTTP_BODY_CHUNK_INDEX = "foam.http.body.chunk.index";
+exports.ATTR_FOAM_HTTP_BODY_CHUNK_BYTES = "foam.http.body.chunk.bytes";
+exports.ATTR_FOAM_HTTP_BODY_CHUNK_CONTENT = "foam.http.body.chunk.content";
+exports.ATTR_FOAM_HTTP_REQUEST_BODY_CAPTURE_ID = "foam.http.request.body.capture_id";
+exports.ATTR_FOAM_HTTP_RESPONSE_BODY_CAPTURE_ID = "foam.http.response.body.capture_id";
+exports.ATTR_FOAM_HTTP_REQUEST_BODY_COMPLETE = "foam.http.request.body.complete";
+exports.ATTR_FOAM_HTTP_RESPONSE_BODY_COMPLETE = "foam.http.response.body.complete";
+exports.ATTR_FOAM_HTTP_REQUEST_BODY_TRUNCATED = "foam.http.request.body.truncated";
+exports.ATTR_FOAM_HTTP_RESPONSE_BODY_TRUNCATED = "foam.http.response.body.truncated";
+exports.SAFE_NETWORK_HEADERS = [
+    "content-type",
+    "content-length",
+    "content-encoding",
+];
+exports.REDACTED_VALUE = "[REDACTED]";
+exports.FULL_MASK = "********";
+exports.TAIL_MASK_THRESHOLD = 12;
+exports.DIAG_LOG_LEVEL = "OTEL_LOG_LEVEL";
+exports.SEVERITY_TEXT = {
+    [api_logs_1.SeverityNumber.TRACE]: "TRACE",
+    [api_logs_1.SeverityNumber.DEBUG]: "DEBUG",
+    [api_logs_1.SeverityNumber.INFO]: "INFO",
+    [api_logs_1.SeverityNumber.WARN]: "WARN",
+    [api_logs_1.SeverityNumber.ERROR]: "ERROR",
+    [api_logs_1.SeverityNumber.FATAL]: "FATAL",
+};

package/dist/endpoint.d.ts

@@ -0,0 +1,2 @@
+export declare let endpoint: string;
+export declare const setEndpoint: (value: string) => void;

package/dist/endpoint.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEndpoint = exports.endpoint = void 0;
+const constants_js_1 = require("./constants.js");
+// pcga11: Defaults to Foam's endpoint and changes only on an explicit setEndpoint
+// call. Exported as a live binding so importers always read the current value.
+exports.endpoint = constants_js_1.FOAM_ENDPOINT;
+const setEndpoint = (value) => {
+    exports.endpoint = value;
+};
+exports.setEndpoint = setEndpoint;

package/dist/exporters.d.ts

@@ -0,0 +1,34 @@
+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";
+import { type BeforeSendHook } from "./before-send.js";
+import { type RedactionConfig } from "./redaction.js";
+type Stamp = Attributes | undefined;
+export interface FoamExporterOptions {
+    readonly redaction?: RedactionConfig;
+    readonly beforeSend?: BeforeSendHook;
+}
+export declare class FoamTraceExporter extends OTLPTraceExporter {
+    private readonly stamp?;
+    private readonly options;
+    constructor(token: string, stamp?: Stamp, options?: FoamExporterOptions);
+    export(spans: ReadableSpan[], callback: (result: ExportResult) => void): void;
+}
+export declare class FoamLogExporter extends OTLPLogExporter {
+    private readonly stamp?;
+    private readonly options;
+    constructor(token: string, stamp?: Stamp, options?: FoamExporterOptions);
+    export(records: ReadableLogRecord[], callback: (result: ExportResult) => void): void;
+}
+export declare class FoamMetricExporter extends OTLPMetricExporter {
+    private readonly stamp?;
+    private readonly options;
+    constructor(token: string, stamp?: Stamp, options?: FoamExporterOptions);
+    export(resourceMetrics: ResourceMetrics, callback: (result: ExportResult) => void): void;
+}
+export {};

package/dist/exporters.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoamMetricExporter = exports.FoamLogExporter = exports.FoamTraceExporter = void 0;
+const core_1 = require("@opentelemetry/core");
+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 before_send_js_1 = require("./before-send.js");
+const constants_js_1 = require("./constants.js");
+const endpoint_js_1 = require("./endpoint.js");
+const redaction_js_1 = require("./redaction.js");
+function redactionConfig(options) {
+    return options.redaction ?? (0, redaction_js_1.getActiveRedactionConfig)();
+}
+// Snapshotting attributes here is safe: every SDK processor (batch/simple
+// span, batch log, periodic metric reader) awaits the resource's
+// waitForAsyncAttributes() before calling the exporter, so detector
+// promises are already resolved.
+function redactedResource(resource, overlay, config) {
+    const merged = overlay ? resource.merge(overlay) : resource;
+    return (0, resources_1.resourceFromAttributes)((0, redaction_js_1.redactAttributesCopy)(merged.attributes, config), { schemaUrl: merged.schemaUrl });
+}
+function copySpan(span, name, attributes, events, links, resource) {
+    return {
+        name,
+        kind: span.kind,
+        spanContext: span.spanContext.bind(span),
+        parentSpanContext: span.parentSpanContext,
+        startTime: span.startTime,
+        endTime: span.endTime,
+        status: span.status,
+        attributes,
+        links,
+        events,
+        duration: span.duration,
+        ended: span.ended,
+        resource,
+        instrumentationScope: span.instrumentationScope,
+        droppedAttributesCount: span.droppedAttributesCount,
+        droppedEventsCount: span.droppedEventsCount,
+        droppedLinksCount: span.droppedLinksCount,
+    };
+}
+class FoamTraceExporter extends exporter_trace_otlp_http_1.OTLPTraceExporter {
+    stamp;
+    options;
+    constructor(token, stamp, options = {}) {
+        super({
+            url: `${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_TRACES_PATH}`,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.stamp = stamp;
+        this.options = options;
+    }
+    export(spans, callback) {
+        const config = redactionConfig(this.options);
+        const overlay = this.stamp ? (0, resources_1.resourceFromAttributes)(this.stamp) : undefined;
+        const output = [];
+        for (const span of spans) {
+            let name = span.name;
+            let sourceAttributes = span.attributes;
+            let sourceEvents = span.events ?? [];
+            let sourceLinks = span.links ?? [];
+            if (this.options.beforeSend) {
+                const result = (0, before_send_js_1.invokeBeforeSend)(this.options.beforeSend, {
+                    type: "span",
+                    name,
+                    attributes: sourceAttributes,
+                    events: sourceEvents,
+                    links: sourceLinks,
+                });
+                if (result === null)
+                    continue;
+                if (result?.type === "span") {
+                    name = result.name;
+                    sourceAttributes = result.attributes;
+                    // Hook-added events may omit time; default it to the span start so
+                    // OTLP serialization stays valid.
+                    sourceEvents = result.events.map((entry) => ({
+                        time: span.startTime,
+                        ...entry,
+                    }));
+                    sourceLinks = result.links;
+                }
+            }
+            const attributes = (0, redaction_js_1.redactAttributesCopy)(sourceAttributes, config);
+            const events = sourceEvents.map((event) => event.attributes
+                ? {
+                    ...event,
+                    attributes: (0, redaction_js_1.redactAttributesCopy)(event.attributes, config),
+                }
+                : event);
+            const links = sourceLinks.map((link) => link.attributes
+                ? {
+                    ...link,
+                    attributes: (0, redaction_js_1.redactAttributesCopy)(link.attributes, config),
+                }
+                : link);
+            output.push(copySpan(span, name, attributes, events, links, redactedResource(span.resource, overlay, config)));
+        }
+        if (output.length === 0) {
+            callback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        super.export(output, callback);
+    }
+}
+exports.FoamTraceExporter = FoamTraceExporter;
+function copyLog(record, body, severityText, attributes, resource) {
+    return {
+        hrTime: record.hrTime,
+        hrTimeObserved: record.hrTimeObserved,
+        spanContext: record.spanContext,
+        severityText,
+        severityNumber: record.severityNumber,
+        body,
+        eventName: record.eventName,
+        resource,
+        instrumentationScope: record.instrumentationScope,
+        attributes,
+        droppedAttributesCount: record.droppedAttributesCount,
+    };
+}
+function redactBody(body, config) {
+    if (body === undefined)
+        return undefined;
+    if (typeof body === "string")
+        return (0, redaction_js_1.redactString)(body, config);
+    return (0, redaction_js_1.redactDeep)(body, config);
+}
+class FoamLogExporter extends exporter_logs_otlp_http_1.OTLPLogExporter {
+    stamp;
+    options;
+    constructor(token, stamp, options = {}) {
+        super({
+            url: `${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_LOGS_PATH}`,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.stamp = stamp;
+        this.options = options;
+    }
+    export(records, callback) {
+        const config = redactionConfig(this.options);
+        const overlay = this.stamp ? (0, resources_1.resourceFromAttributes)(this.stamp) : undefined;
+        const output = [];
+        for (const record of records) {
+            let sourceBody = record.body;
+            let severityText = record.severityText;
+            let sourceAttributes = record.attributes;
+            if (this.options.beforeSend) {
+                const result = (0, before_send_js_1.invokeBeforeSend)(this.options.beforeSend, {
+                    type: "log",
+                    body: sourceBody,
+                    severityText,
+                    attributes: sourceAttributes,
+                });
+                if (result === null)
+                    continue;
+                if (result?.type === "log") {
+                    sourceBody = result.body;
+                    severityText = result.severityText;
+                    sourceAttributes = result.attributes;
+                }
+            }
+            const body = redactBody(sourceBody, config);
+            const attributes = (0, redaction_js_1.redactAttributesCopy)(sourceAttributes, config);
+            output.push(copyLog(record, body, severityText, attributes, redactedResource(record.resource, overlay, config)));
+        }
+        if (output.length === 0) {
+            callback({ code: core_1.ExportResultCode.SUCCESS });
+            return;
+        }
+        super.export(output, callback);
+    }
+}
+exports.FoamLogExporter = FoamLogExporter;
+class FoamMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporter {
+    stamp;
+    options;
+    constructor(token, stamp, options = {}) {
+        super({
+            url: `${endpoint_js_1.endpoint}${constants_js_1.FOAM_OTLP_METRICS_PATH}`,
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        this.stamp = stamp;
+        this.options = options;
+    }
+    export(resourceMetrics, callback) {
+        const config = redactionConfig(this.options);
+        const overlay = this.stamp ? (0, resources_1.resourceFromAttributes)(this.stamp) : undefined;
+        super.export({
+            ...resourceMetrics,
+            resource: redactedResource(resourceMetrics.resource, overlay, config),
+            scopeMetrics: resourceMetrics.scopeMetrics.map((scope) => ({
+                ...scope,
+                metrics: scope.metrics.map((metric) => ({
+                    ...metric,
+                    dataPoints: metric.dataPoints.map((point) => ({
+                        ...point,
+                        attributes: (0, redaction_js_1.redactAttributesCopy)(point.attributes, config),
+                    })),
+                })),
+            })),
+        }, callback);
+    }
+}
+exports.FoamMetricExporter = FoamMetricExporter;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { init, type InitOptions } from "./init.js";
+export type { BeforeSendEvent, BeforeSendHook, } from "./before-send.js";
+export type { RedactOptions } from "./redaction.js";
+export { getState } from "./state.js";
+export { setEndpoint } from "./endpoint.js";
+export { createFoamIngestLogRecordProcessor, createFoamIngestMetricReader, createFoamIngestSpanProcessor, type FoamIngestOptions, } from "./ingest.js";
+export { extractTraceContext, getBaggage, injectTraceContext, setBaggage, } from "./propagation.js";
+export { addUpDownCounter, incrementCounter, recordHistogram, setMetric, } from "./metrics.js";
+export { log, SeverityNumber } from "./logs.js";
+export { recordException } from "./traces.js";

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordException = exports.SeverityNumber = exports.log = exports.setMetric = exports.recordHistogram = exports.incrementCounter = exports.addUpDownCounter = exports.setBaggage = exports.injectTraceContext = exports.getBaggage = exports.extractTraceContext = exports.createFoamIngestSpanProcessor = exports.createFoamIngestMetricReader = exports.createFoamIngestLogRecordProcessor = exports.setEndpoint = 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 endpoint_js_1 = require("./endpoint.js");
+Object.defineProperty(exports, "setEndpoint", { enumerable: true, get: function () { return endpoint_js_1.setEndpoint; } });
+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; } });
+var logs_js_1 = require("./logs.js");
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return logs_js_1.log; } });
+Object.defineProperty(exports, "SeverityNumber", { enumerable: true, get: function () { return logs_js_1.SeverityNumber; } });
+var traces_js_1 = require("./traces.js");
+Object.defineProperty(exports, "recordException", { enumerable: true, get: function () { return traces_js_1.recordException; } });

package/dist/ingest.d.ts

@@ -0,0 +1,12 @@
+import { type LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { type BeforeSendHook } from "./before-send.js";
+import { type RedactOptions } from "./redaction.js";
+export interface FoamIngestOptions {
+    readonly redact?: RedactOptions;
+    readonly beforeSend?: BeforeSendHook;
+}
+export declare function createFoamIngestSpanProcessor(name: string, environment: string, token: string, options?: FoamIngestOptions): SpanProcessor;
+export declare function createFoamIngestLogRecordProcessor(name: string, environment: string, token: string, options?: FoamIngestOptions): LogRecordProcessor;
+export declare function createFoamIngestMetricReader(name: string, environment: string, token: string, options?: FoamIngestOptions): PeriodicExportingMetricReader;

package/dist/ingest.js

@@ -0,0 +1,70 @@
+"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 before_send_js_1 = require("./before-send.js");
+const constants_js_1 = require("./constants.js");
+const report_js_1 = require("./report.js");
+const exporters_js_1 = require("./exporters.js");
+const logs_js_1 = require("./logs.js");
+const redaction_js_1 = require("./redaction.js");
+const state_js_1 = require("./state.js");
+function prepareOptions(options) {
+    return {
+        redaction: (0, redaction_js_1.resolveRedactionConfig)(options.redact),
+        beforeSend: (0, before_send_js_1.resolveBeforeSend)(options.beforeSend),
+    };
+}
+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.ATTR_FOAM_INGEST_HOST]: constants_js_1.FOAM_INGEST_HOST,
+        },
+    };
+}
+function reportIngestSignal(signal, name, environment, token) {
+    (0, state_js_1.setSignal)(signal, state_js_1.SignalSources.ingest);
+    // pcga11: report() prefixes the identifier itself; adding it here would double it.
+    (0, report_js_1.report)({
+        token: token,
+        name: name,
+        environment: environment,
+        severity: api_logs_1.SeverityNumber.INFO,
+        message: `ingest ${signal} processor attached`,
+    });
+}
+function createFoamIngestSpanProcessor(name, environment, token, options = {}) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const processor = new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(token, stamp, prepareOptions(options)));
+    reportIngestSignal(state_js_1.Signals.traces, name, environment, token);
+    return processor;
+}
+function createFoamIngestLogRecordProcessor(name, environment, token, options = {}) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const prepared = prepareOptions(options);
+    const processor = new sdk_logs_1.BatchLogRecordProcessor({
+        exporter: new exporters_js_1.FoamLogExporter(token, stamp, prepared),
+    });
+    (0, logs_js_1.ensureFoamLoggerProvider)(name, environment, token, stamp, prepared);
+    reportIngestSignal(state_js_1.Signals.logs, name, environment, token);
+    return processor;
+}
+function createFoamIngestMetricReader(name, environment, token, options = {}) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const reader = new sdk_metrics_1.PeriodicExportingMetricReader({
+        exporter: new exporters_js_1.FoamMetricExporter(token, stamp, prepareOptions(options)),
+    });
+    reportIngestSignal(state_js_1.Signals.metrics, name, environment, token);
+    return reader;
+}

package/dist/init.d.ts

@@ -0,0 +1,26 @@
+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";
+import { type BeforeSendHook } from "./before-send.js";
+import { type RedactOptions } from "./redaction.js";
+export interface InitOptions {
+    name: string;
+    environment: string;
+    token?: string;
+    version?: string;
+    sampleRate?: number;
+    disableLogSending?: boolean;
+    networkCapture?: "off" | "basic" | "advanced";
+    enabled?: boolean;
+    redact?: RedactOptions;
+    beforeSend?: BeforeSendHook;
+    additionalInstrumentations?: readonly Instrumentation[];
+    additionalSpanProcessors?: readonly SpanProcessor[];
+    additionalLogRecordProcessors?: readonly LogRecordProcessor[];
+    additionalMetricReaders?: readonly MetricReader[];
+    additionalResourceAttributes?: Attributes;
+    ignoredOutboundHosts?: readonly string[];
+}
+export declare function init(options: InitOptions): void;