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

package/dist/constants.d.ts

@@ -0,0 +1,43 @@
+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 FOAM_IDENTIFIER_NAME = "[foam-otel]";
+export declare const FOAM_DISTRO_NAME = "@foam-ai/node";
+export declare const FOAM_DISTRO_VERSION = "0.1.0-alpha.7";
+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 SENSITIVE_BODY_KEY_PATTERNS: readonly ["password", "passwd", "passphrase", "secret", "token", "apikey", "authorization", "credential", "privatekey", "sessionid", "creditcard", "cardnumber", "accountnumber", "routingnumber"];
+export declare const SENSITIVE_BODY_KEYS_EXACT: readonly ["auth", "pwd", "pin", "otp", "cvv", "cvc", "ssn", "key", "cookie", "setcookie", "session"];
+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,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEVERITY_TEXT = exports.DIAG_LOG_LEVEL = exports.SENSITIVE_BODY_KEYS_EXACT = exports.SENSITIVE_BODY_KEY_PATTERNS = 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.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.FOAM_IDENTIFIER_NAME = "[foam-otel]";
+exports.FOAM_DISTRO_NAME = "@foam-ai/node";
+exports.FOAM_DISTRO_VERSION = "0.1.0-alpha.7";
+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]";
+// pcga11: Matched against body keys after lowercasing and stripping the
+// -_. separators, so "api-key", "apiKey", and "API_KEY" all normalize to
+// "apikey". Patterns match anywhere in the key ("user_password" is caught);
+// exact keys are too short or too common to substring-match safely.
+exports.SENSITIVE_BODY_KEY_PATTERNS = [
+    "password",
+    "passwd",
+    "passphrase",
+    "secret",
+    "token",
+    "apikey",
+    "authorization",
+    "credential",
+    "privatekey",
+    "sessionid",
+    "creditcard",
+    "cardnumber",
+    "accountnumber",
+    "routingnumber",
+];
+exports.SENSITIVE_BODY_KEYS_EXACT = [
+    "auth",
+    "pwd",
+    "pin",
+    "otp",
+    "cvv",
+    "cvc",
+    "ssn",
+    "key",
+    "cookie",
+    "setcookie",
+    "session",
+];
+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,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,103 @@
+"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");
+const endpoint_js_1 = require("./endpoint.js");
+class FoamTraceExporter extends exporter_trace_otlp_http_1.OTLPTraceExporter {
+    stamp;
+    constructor(token, stamp) {
+        super({
+            url: `${endpoint_js_1.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);
+        const copies = spans.map((span) => ({
+            name: span.name,
+            kind: span.kind,
+            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: `${endpoint_js_1.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: `${endpoint_js_1.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,7 @@
+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";
+export { log, SeverityNumber } from "./logs.js";
+export { recordException } from "./traces.js";

package/dist/index.js

@@ -0,0 +1,26 @@
+"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.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; } });
+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,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,61 @@
+"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 report_js_1 = require("./report.js");
+const exporters_js_1 = require("./exporters.js");
+const logs_js_1 = require("./logs.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_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) {
+    const { stamp } = prepareStamp(name, environment, token);
+    const processor = new sdk_trace_base_1.BatchSpanProcessor(new exporters_js_1.FoamTraceExporter(token, stamp));
+    reportIngestSignal(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),
+    });
+    (0, logs_js_1.ensureFoamLoggerProvider)(name, environment, token, stamp);
+    reportIngestSignal(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),
+    });
+    reportIngestSignal(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 interface InitOptions {
+    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[];
+}
+export declare function init(options: InitOptions): void;

package/dist/init.js

@@ -0,0 +1,150 @@
+"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 logs_js_1 = require("./logs.js");
+const state_js_1 = require("./state.js");
+// TODO(pcga11): conflicts, redact and beforeSend handling pending.
+function init(options) {
+    const { sampleRate = 1, disableLogSending = false, networkCapture = "basic", enabled = true, } = options;
+    // 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;
+    }
+    // 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 {
+        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)),
+                ...(options.additionalSpanProcessors ?? []),
+            ],
+        });
+        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 ?? []),
+            ],
+        });
+        (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.instrumentationName));
+        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,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;