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

package/dist/otlp.js

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

package/dist/report.d.ts

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

package/dist/report.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.report = report;
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const core_1 = require("@opentelemetry/core");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const constants_js_1 = require("./constants.js");
+const otlp_js_1 = require("./otlp.js");
+const state_js_1 = require("./state.js");
+const logger = api_1.diag.createComponentLogger({ namespace: constants_js_1.FOAM_IDENTIFIER_NAME });
+// pcga11: Guarded so repeat report() calls don't trigger diag's "logger will be overwritten" warning.
+let reportingConfigured = false;
+function ensureReportingConfigured() {
+    if (reportingConfigured) {
+        return;
+    }
+    reportingConfigured = true;
+    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);
+}
+// pcga11: State reports go to Foam's OTLP endpoint directly instead of through the
+// logger provider or exporter, since those may themselves be broken or unregistered.
+async function report({ name, environment, token, severity, message, error, }) {
+    ensureReportingConfigured();
+    // pcga11: Local diag logging happens before the token check so misconfiguration
+    // is visible in the console even when nothing can be sent.
+    if (severity >= api_logs_1.SeverityNumber.ERROR) {
+        logger.error(message);
+    }
+    else if (severity >= api_logs_1.SeverityNumber.WARN) {
+        logger.warn(message);
+    }
+    else {
+        logger.info(message);
+    }
+    // pcga11: Token is the only hard requirement (nothing can be sent without auth).
+    // name/environment fall back to "unknown" so misconfiguration reports still arrive.
+    if (!token) {
+        return;
+    }
+    await (0, otlp_js_1.sendOtlpLog)({
+        token: token,
+        resourceAttributes: {
+            [semantic_conventions_1.ATTR_SERVICE_NAME]: name?.trim() || "unknown",
+            [semantic_conventions_1.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: environment?.trim() || "unknown",
+        },
+        scopeName: constants_js_1.FOAM_IDENTIFIER_NAME,
+        severityNumber: severity,
+        body: JSON.stringify({
+            state: { ...(0, state_js_1.getState)() },
+            message: `${constants_js_1.FOAM_IDENTIFIER_NAME} ${message}`,
+            error: error,
+        }),
+    });
+}

package/dist/state.d.ts

@@ -5,15 +5,22 @@ export declare enum Signals {
     baggage = "baggage",
     profile = "profile"
 }
-/** Read-only view of the SDK state; mutated only via the setters in state.ts. */
+export declare enum SignalSources {
+    none = "none",
+    global = "global",
+    ingest = "ingest",
+    local = "local"
+}
 export interface State {
     readonly initialized: boolean;
     readonly instrumentations: readonly string[];
-    readonly signals: Readonly<Record<Signals, boolean>>;
+    readonly signals: Readonly<Record<Signals, SignalSources>>;
+    readonly params: Readonly<Record<string, unknown>>;
 }
 export declare const setInstrumentations: (names: readonly string[]) => void;
-export declare const setSignal: (signal: Signals, enabled: boolean) => void;
-export declare const getSignal: (signal: Signals) => boolean;
+export declare const setSignal: (signal: Signals, source: SignalSources) => void;
+export declare const getSignal: (signal: Signals) => SignalSources;
 export declare const setInitialized: (initialized: boolean) => void;
 export declare const getInitialized: () => boolean;
+export declare const setParams: (params: Record<string, unknown>) => void;
 export declare const getState: () => State;

package/dist/state.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getState = exports.getInitialized = exports.setInitialized = exports.getSignal = exports.setSignal = exports.setInstrumentations = exports.Signals = void 0;
+exports.getState = exports.setParams = exports.getInitialized = exports.setInitialized = exports.getSignal = exports.setSignal = exports.setInstrumentations = exports.SignalSources = exports.Signals = void 0;
 var Signals;
 (function (Signals) {
     Signals["traces"] = "traces";
@@ -9,23 +9,31 @@ var Signals;
     Signals["baggage"] = "baggage";
     Signals["profile"] = "profile";
 })(Signals || (exports.Signals = Signals = {}));
+var SignalSources;
+(function (SignalSources) {
+    SignalSources["none"] = "none";
+    SignalSources["global"] = "global";
+    SignalSources["ingest"] = "ingest";
+    SignalSources["local"] = "local";
+})(SignalSources || (exports.SignalSources = SignalSources = {}));
 const state = {
     initialized: false,
-    instrumentations: [],
+    instrumentations: [], // pcga11: The registered instrumentations that are enabled in the current application.
     signals: {
-        traces: false,
-        metrics: false,
-        logs: false,
-        baggage: false,
-        profile: false,
+        traces: SignalSources.none,
+        metrics: SignalSources.none,
+        logs: SignalSources.none,
+        baggage: SignalSources.none,
+        profile: SignalSources.none,
     },
+    params: {},
 };
 const setInstrumentations = (names) => {
     state.instrumentations = [...names];
 };
 exports.setInstrumentations = setInstrumentations;
-const setSignal = (signal, enabled) => {
-    state.signals[signal] = enabled;
+const setSignal = (signal, source) => {
+    state.signals[signal] = source;
 };
 exports.setSignal = setSignal;
 const getSignal = (signal) => state.signals[signal];
@@ -36,9 +44,18 @@ const setInitialized = (initialized) => {
 exports.setInitialized = setInitialized;
 const getInitialized = () => state.initialized;
 exports.getInitialized = getInitialized;
+const setParams = (params) => {
+    // pcga11: Safety precaution: never store tokens in the state.
+    if (params.token) {
+        delete params.token;
+    }
+    state.params = { ...params };
+};
+exports.setParams = setParams;
 const getState = () => ({
     initialized: state.initialized,
     instrumentations: [...state.instrumentations],
     signals: { ...state.signals },
+    params: { ...state.params },
 });
 exports.getState = getState;

package/dist/traces.d.ts

@@ -0,0 +1 @@
+export declare function recordException(error: unknown): void;

package/dist/traces.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordException = recordException;
+const api_1 = require("@opentelemetry/api");
+const utils_js_1 = require("./utils.js");
+// pcga11: Not gated on the traces signal on purpose: the active span belongs to
+// whichever SDK owns tracing, and the exception should land on that span either way.
+function recordException(error) {
+    (0, utils_js_1.safely)(() => {
+        const span = api_1.trace.getActiveSpan();
+        if (!span?.isRecording()) {
+            return;
+        }
+        const exception = error instanceof Error ? error : String(error);
+        span.recordException(exception);
+        span.setStatus({
+            code: api_1.SpanStatusCode.ERROR,
+            message: error instanceof Error ? error.message : String(error),
+        });
+    });
+}

package/dist/utils.js

@@ -13,7 +13,7 @@ function safely(operation, fallback) {
 }
 function whenInitialized(signal, operation) {
     return (...args) => {
-        if (!(0, state_js_1.getSignal)(signal))
+        if ((0, state_js_1.getSignal)(signal) === state_js_1.SignalSources.none)
             return;
         safely(() => operation(...args));
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foam-ai/node",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.5",
   "description": "Foam JavaScript Node.js SDK",
   "license": "Apache-2.0",
   "repository": {

package/dist/diagnostics.d.ts

@@ -1,13 +0,0 @@
-import { SeverityNumber } from "@opentelemetry/api-logs";
-export declare function configureDiagnostics(): void;
-export declare const info: (message: string) => void;
-export declare const warn: (message: string) => void;
-export declare const error: (message: string) => void;
-export declare function sendStateDiagnosticLog({ name, environment, token, tier, severity, error, }: {
-    name: string;
-    environment: string;
-    token: string;
-    tier: "internal" | "external";
-    severity: SeverityNumber;
-    error?: string;
-}): Promise<void>;

package/dist/diagnostics.js

@@ -1,83 +0,0 @@
-"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.
-    }
-}