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

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/resource.d.ts

@@ -0,0 +1,3 @@
+import type { Attributes } from "@opentelemetry/api";
+import { type Resource } from "@opentelemetry/resources";
+export declare function createFoamResource(name: string, environment: string, version?: string, additionalResourceAttributes?: Attributes): Resource;

package/dist/resource.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFoamResource = createFoamResource;
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const constants_js_1 = require("./constants.js");
+function createFoamResource(name, environment, version, additionalResourceAttributes) {
+    return (0, resources_1.defaultResource)()
+        .merge((0, resources_1.detectResources)({
+        detectors: [resources_1.envDetector, resources_1.processDetector, resources_1.hostDetector, resources_1.osDetector],
+    }))
+        // pcga11: Later merges overwrite colliding keys, so Foam name/env/version will win over detectors.
+        // This is the desired behavior. Do not change.
+        .merge((0, resources_1.resourceFromAttributes)({
+        ...additionalResourceAttributes,
+        [semantic_conventions_1.ATTR_SERVICE_NAME]: name,
+        [semantic_conventions_1.ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: environment,
+        ...(version
+            ? { [semantic_conventions_1.ATTR_SERVICE_VERSION]: version }
+            : {}),
+        [semantic_conventions_1.ATTR_TELEMETRY_DISTRO_NAME]: constants_js_1.FOAM_DISTRO_NAME,
+        [semantic_conventions_1.ATTR_TELEMETRY_DISTRO_VERSION]: constants_js_1.FOAM_DISTRO_VERSION,
+    }));
+}

package/dist/state.d.ts

@@ -0,0 +1,26 @@
+export declare enum Signals {
+    traces = "traces",
+    metrics = "metrics",
+    logs = "logs",
+    baggage = "baggage",
+    profile = "profile"
+}
+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, SignalSources>>;
+    readonly params: Readonly<Record<string, unknown>>;
+}
+export declare const setInstrumentations: (names: readonly string[]) => void;
+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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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";
+    Signals["metrics"] = "metrics";
+    Signals["logs"] = "logs";
+    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: [], // pcga11: The registered instrumentations that are enabled in the current application.
+    signals: {
+        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, source) => {
+    state.signals[signal] = source;
+};
+exports.setSignal = setSignal;
+const getSignal = (signal) => state.signals[signal];
+exports.getSignal = getSignal;
+const setInitialized = (initialized) => {
+    state.initialized = 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.d.ts

@@ -0,0 +1,4 @@
+import { Signals } from "./state.js";
+export declare function safely<T>(operation: () => T, fallback: T): T;
+export declare function safely(operation: () => void): void;
+export declare function whenInitialized<A extends unknown[]>(signal: Signals, operation: (...args: A) => void): (...args: A) => void;

package/dist/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safely = safely;
+exports.whenInitialized = whenInitialized;
+const state_js_1 = require("./state.js");
+function safely(operation, fallback) {
+    try {
+        return operation();
+    }
+    catch {
+        return fallback;
+    }
+}
+function whenInitialized(signal, operation) {
+    return (...args) => {
+        if ((0, state_js_1.getSignal)(signal) === state_js_1.SignalSources.none)
+            return;
+        safely(() => operation(...args));
+    };
+}

package/package.json

@@ -1,35 +1,63 @@
 {
   "name": "@foam-ai/node",
-  "version": "0.1.0-alpha.3",
-  "main": "dist/node/src/index.js",
-  "types": "dist/node/src/index.d.ts",
+  "version": "0.1.0-alpha.5",
+  "description": "Foam JavaScript Node.js SDK",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/foam-ai/js-node.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "engines": {
+    "node": "^18.19.0 || >=20.6.0"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/node/src/index.d.ts",
-      "import": "./dist/node/src/index.js",
-      "require": "./dist/node/src/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json"
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": "^0.214.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.214.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
-    "@opentelemetry/instrumentation": "^0.214.0",
-    "@opentelemetry/resources": "^2.6.1",
-    "@opentelemetry/sdk-logs": "^0.214.0",
-    "@opentelemetry/sdk-metrics": "^2.6.1",
-    "@opentelemetry/sdk-trace-base": "^2.6.1",
-    "@opentelemetry/sdk-trace-node": "^2.6.1"
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.221.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.79.0",
+    "@opentelemetry/context-async-hooks": "^2.10.0",
+    "@opentelemetry/core": "^2.10.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.221.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.221.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
+    "@opentelemetry/instrumentation": "^0.221.0",
+    "@opentelemetry/instrumentation-console": "^0.3.0",
+    "@opentelemetry/instrumentation-http": "^0.221.0",
+    "@opentelemetry/instrumentation-undici": "^0.31.0",
+    "@opentelemetry/otlp-transformer": "^0.221.0",
+    "@opentelemetry/resources": "^2.10.0",
+    "@opentelemetry/sdk-logs": "^0.221.0",
+    "@opentelemetry/sdk-metrics": "^2.10.0",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "@opentelemetry/winston-transport": "^0.31.0"
   },
   "devDependencies": {
-    "typescript": "^6.0.2"
+    "@types/node": "^26.2.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
   }
 }

package/dist/node/src/capture-exception.d.ts

@@ -1,9 +0,0 @@
-/**
- * Captures an exception and sends it to Foam.
- *
- * - Records on the active span if one exists (for trace-level visibility)
- * - Always emits an OTEL log record so the error reaches Foam even when
- *   there is no active span or auto-instrumentation
- * - Safe to call at any time — silently no-ops if the SDK isn't initialized
- */
-export declare const captureException: (error: unknown) => void;

package/dist/node/src/capture-exception.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.captureException = void 0;
-const api_1 = require("@opentelemetry/api");
-const api_logs_1 = require("@opentelemetry/api-logs");
-const util_1 = require("../../shared/util");
-/**
- * Captures an exception and sends it to Foam.
- *
- * - Records on the active span if one exists (for trace-level visibility)
- * - Always emits an OTEL log record so the error reaches Foam even when
- *   there is no active span or auto-instrumentation
- * - Safe to call at any time — silently no-ops if the SDK isn't initialized
- */
-exports.captureException = (0, util_1.safe)((error) => {
-    const err = error instanceof Error ? error : new Error(String(error));
-    const span = api_1.trace.getActiveSpan();
-    if (span) {
-        span.recordException(err);
-        span.setStatus({ code: api_1.SpanStatusCode.ERROR });
-    }
-    api_logs_1.logs.getLogger('foam').emit({
-        severityNumber: api_logs_1.SeverityNumber.ERROR,
-        severityText: 'ERROR',
-        body: err.message,
-        attributes: {
-            'exception.type': err.name,
-            'exception.stacktrace': err.stack ?? '',
-        },
-    });
-});

package/dist/node/src/index.d.ts

@@ -1,13 +0,0 @@
-import { captureException } from './capture-exception';
-import { init } from './init';
-import { incrementCounter, recordHistogram, recordGauge } from './metrics';
-export { captureException, init, incrementCounter, recordHistogram, recordGauge };
-export type { FoamNodeInitOptions } from './init';
-declare const foam: {
-    captureException: (error: unknown) => void;
-    init: (options: import("./init").FoamNodeInitOptions) => void;
-    incrementCounter: (name: string, value?: number, attributes?: import("@opentelemetry/api").Attributes) => void;
-    recordHistogram: (name: string, value: number, attributes?: import("@opentelemetry/api").Attributes) => void;
-    recordGauge: (name: string, value: number, attributes?: import("@opentelemetry/api").Attributes) => void;
-};
-export default foam;

package/dist/node/src/index.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordGauge = exports.recordHistogram = exports.incrementCounter = exports.init = exports.captureException = void 0;
-const capture_exception_1 = require("./capture-exception");
-Object.defineProperty(exports, "captureException", { enumerable: true, get: function () { return capture_exception_1.captureException; } });
-const init_1 = require("./init");
-Object.defineProperty(exports, "init", { enumerable: true, get: function () { return init_1.init; } });
-const metrics_1 = require("./metrics");
-Object.defineProperty(exports, "incrementCounter", { enumerable: true, get: function () { return metrics_1.incrementCounter; } });
-Object.defineProperty(exports, "recordHistogram", { enumerable: true, get: function () { return metrics_1.recordHistogram; } });
-Object.defineProperty(exports, "recordGauge", { enumerable: true, get: function () { return metrics_1.recordGauge; } });
-const foam = {
-    captureException: capture_exception_1.captureException,
-    init: init_1.init,
-    incrementCounter: metrics_1.incrementCounter,
-    recordHistogram: metrics_1.recordHistogram,
-    recordGauge: metrics_1.recordGauge,
-};
-exports.default = foam;

package/dist/node/src/init.d.ts

@@ -1,27 +0,0 @@
-import type { InstrumentationBase } from '@opentelemetry/instrumentation';
-export interface FoamNodeInitOptions {
-    apiKey: string;
-    serviceName: string;
-    isProduction: boolean;
-    /**
-     * OpenTelemetry instrumentations to register (e.g. getNodeAutoInstrumentations()).
-     * None are registered by default to keep the SDK webpack/Turbopack-safe.
-     * For plain Node.js servers, pass getNodeAutoInstrumentations() to get
-     * automatic HTTP, Express, DNS, etc. instrumentation.
-     */
-    instrumentations?: InstrumentationBase[];
-}
-/**
- * Initializes the Foam SDK for Node.js.
- *
- * - Production-only: silently no-ops when `isProduction` is false.
- * - Zero latency: all setup is synchronous object construction; actual telemetry
- *   export happens asynchronously in background batch intervals.
- * - Crash-safe: every signal is wrapped in its own try/catch so a failure in
- *   one (e.g. traces) never prevents the others (logs, metrics) from starting.
- * - Provider-aware: detects each OTEL signal independently. If another SDK
- *   (Sentry, @vercel/otel, etc.) already registered a provider, Foam attaches
- *   its exporters on top. If no provider exists, Foam creates one. This
- *   guarantees all three signals always reach Foam regardless of environment.
- */
-export declare const init: (options: FoamNodeInitOptions) => void;

package/dist/node/src/init.js

@@ -1,218 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.init = void 0;
-const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
-const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
-const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
-const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
-const sdk_logs_1 = require("@opentelemetry/sdk-logs");
-const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
-const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
-const instrumentation_1 = require("@opentelemetry/instrumentation");
-const api_1 = require("@opentelemetry/api");
-const api_logs_1 = require("@opentelemetry/api-logs");
-const resources_1 = require("@opentelemetry/resources");
-const util_1 = require("util");
-const constants_1 = require("../../shared/constants");
-const util_2 = require("../../shared/util");
-const capture_exception_1 = require("./capture-exception");
-/**
- * Initializes the Foam SDK for Node.js.
- *
- * - Production-only: silently no-ops when `isProduction` is false.
- * - Zero latency: all setup is synchronous object construction; actual telemetry
- *   export happens asynchronously in background batch intervals.
- * - Crash-safe: every signal is wrapped in its own try/catch so a failure in
- *   one (e.g. traces) never prevents the others (logs, metrics) from starting.
- * - Provider-aware: detects each OTEL signal independently. If another SDK
- *   (Sentry, @vercel/otel, etc.) already registered a provider, Foam attaches
- *   its exporters on top. If no provider exists, Foam creates one. This
- *   guarantees all three signals always reach Foam regardless of environment.
- */
-exports.init = (0, util_2.safe)((options) => {
-    if (!options.isProduction) {
-        return;
-    }
-    const headers = { authorization: `Bearer ${options.apiKey}` };
-    const resource = (0, resources_1.resourceFromAttributes)({ 'service.name': options.serviceName });
-    // Each signal is independent — a failure in one must not block the others
-    safeRun(() => ensureTraces(headers, resource, options.instrumentations));
-    safeRun(() => ensureLogs(headers, resource));
-    safeRun(() => ensureMetrics(headers, resource));
-    safeRun(() => patchConsole());
-    safeRun(() => registerProcessErrorHandlers());
-});
-// ---------------------------------------------------------------------------
-// Per-signal setup
-//
-// For each signal the pattern is:
-//   1. Create a batch processor/reader with an HTTP OTLP exporter
-//   2. Check if a real provider is already registered globally
-//   3. If yes → attach the processor to the existing provider
-//   4. If no  → create a new provider and register it globally
-//
-// All exporters use HTTP (not gRPC) to stay webpack/Turbopack-compatible.
-// Batch processors buffer spans/logs in memory and flush asynchronously,
-// so init() returns instantly with zero latency impact on the caller.
-// ---------------------------------------------------------------------------
-function ensureTraces(headers, resource, instrumentations) {
-    const processor = new sdk_trace_base_1.BatchSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: `${constants_1.FOAM_OTEL_ENDPOINT}/v1/traces`, headers }));
-    const existing = unwrapProvider(api_1.trace.getTracerProvider());
-    if (!addProcessor(existing, 'addSpanProcessor', '_activeSpanProcessor', processor)) {
-        new sdk_trace_node_1.NodeTracerProvider({ resource, spanProcessors: [processor] }).register();
-    }
-    if (instrumentations?.length) {
-        (0, instrumentation_1.registerInstrumentations)({ instrumentations });
-    }
-}
-function ensureLogs(headers, resource) {
-    const processor = new sdk_logs_1.BatchLogRecordProcessor(new exporter_logs_otlp_http_1.OTLPLogExporter({ url: `${constants_1.FOAM_OTEL_ENDPOINT}/v1/logs`, headers }));
-    const existing = unwrapProvider(api_logs_1.logs.getLoggerProvider());
-    if (!addProcessor(existing, 'addLogRecordProcessor', '_sharedState', processor)) {
-        const provider = new sdk_logs_1.LoggerProvider({ resource, processors: [processor] });
-        api_logs_1.logs.setGlobalLoggerProvider(provider);
-    }
-}
-function ensureMetrics(headers, resource) {
-    const reader = new sdk_metrics_1.PeriodicExportingMetricReader({
-        exporter: new exporter_metrics_otlp_http_1.OTLPMetricExporter({
-            url: `${constants_1.FOAM_OTEL_ENDPOINT}/v1/metrics`,
-            headers,
-        }),
-    });
-    const existing = unwrapProvider(api_1.metrics.getMeterProvider());
-    if (!addProcessor(existing, 'addMetricReader', '_sharedState', reader)) {
-        const provider = new sdk_metrics_1.MeterProvider({ resource, readers: [reader] });
-        api_1.metrics.setGlobalMeterProvider(provider);
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Runs a function, swallowing any error so one failed signal can't block others. */
-function safeRun(fn) {
-    try {
-        fn();
-    }
-    catch { /* intentionally swallowed */ }
-}
-/**
- * Unwraps proxy/noop providers to get the real delegate.
- *
- * OTEL wraps every global provider in a Proxy (ProxyTracerProvider,
- * ProxyLoggerProvider, etc.). Before checking for methods like
- * addSpanProcessor we need the real underlying provider.
- *
- * Returns {} for noop providers so callers can safely check for methods
- * with typeof without null guards.
- */
-function unwrapProvider(provider) {
-    const delegate = typeof provider.getDelegate === 'function'
-        ? provider.getDelegate()
-        : provider._delegate ?? provider;
-    if (!delegate || delegate.constructor?.name?.startsWith('Noop'))
-        return {};
-    return delegate;
-}
-/**
- * Attempts to add a processor/reader to an existing provider.
- *
- * Strategy:
- *   1. Try the public v1 method (addSpanProcessor, addLogRecordProcessor, addMetricReader)
- *   2. Fall back to pushing into internal arrays used by SDK v2:
- *      - Traces: provider._activeSpanProcessor._spanProcessors
- *      - Logs:   provider._sharedState.registeredLogRecordProcessors
- *      - Metrics: provider._sharedState has no writable reader array, so metrics
- *                 always creates a new provider if the public method is missing
- *
- * All internal access is guarded by Array.isArray — safe if internals change.
- * Returns true if successfully attached, false if a new provider is needed.
- */
-function addProcessor(provider, v1Method, v2Field, processor) {
-    if (typeof provider[v1Method] === 'function') {
-        provider[v1Method](processor);
-        return true;
-    }
-    const state = provider[v2Field];
-    if (!state)
-        return false;
-    const internal = state._spanProcessors ??
-        state._processors ??
-        state.registeredLogRecordProcessors;
-    if (Array.isArray(internal)) {
-        internal.push(processor);
-        return true;
-    }
-    return false;
-}
-// ---------------------------------------------------------------------------
-// Uncaught error handlers
-//
-// Listens to process-level uncaughtException and unhandledRejection events
-// to capture errors that escape all try/catch blocks. Works for any framework
-// (Express, Fastify, Koa, Next.js, plain Node.js, background jobs, etc.).
-// Idempotent — safe to call multiple times. Never interferes with the app's
-// default crash behavior since we only listen (not override).
-// ---------------------------------------------------------------------------
-const PROCESS_HANDLERS_INSTALLED = Symbol.for('foam.process.handlers');
-function registerProcessErrorHandlers() {
-    if (globalThis[PROCESS_HANDLERS_INSTALLED])
-        return;
-    process.on('uncaughtException', (err) => {
-        try {
-            (0, capture_exception_1.captureException)(err);
-        }
-        catch { /* never interfere with the crash */ }
-    });
-    process.on('unhandledRejection', (reason) => {
-        try {
-            (0, capture_exception_1.captureException)(reason);
-        }
-        catch { /* never interfere with the crash */ }
-    });
-    globalThis[PROCESS_HANDLERS_INSTALLED] = true;
-}
-// ---------------------------------------------------------------------------
-// Console log capture
-//
-// Wraps console.log/info/error/warn/debug to emit OTel log records.
-// Uses a Symbol to ensure idempotency — safe to call multiple times
-// or if another SDK has already patched console.
-// The original console method is always called first so there's zero
-// impact on the application's logging behavior or latency.
-// ---------------------------------------------------------------------------
-const PATCHED = Symbol.for('foam.console.patched');
-function patchConsole() {
-    if (console[PATCHED])
-        return;
-    const logger = api_logs_1.logs.getLogger('console');
-    const patch = (method, severityNumber, severityText) => {
-        const original = console[method].bind(console);
-        console[method] = (...args) => {
-            original(...args);
-            let ctx;
-            let traceAttributes;
-            try {
-                ctx = api_1.context.active();
-                const spanContext = api_1.trace.getSpanContext(ctx);
-                if (spanContext && (0, api_1.isSpanContextValid)(spanContext)) {
-                    traceAttributes = { 'trace.id': spanContext.traceId, 'span.id': spanContext.spanId };
-                }
-            }
-            catch { /* never break the caller's console.log */ }
-            logger.emit({
-                context: ctx,
-                severityNumber,
-                severityText,
-                body: (0, util_1.format)(...args),
-                attributes: traceAttributes,
-            });
-        };
-    };
-    patch('log', api_logs_1.SeverityNumber.INFO, 'INFO');
-    patch('info', api_logs_1.SeverityNumber.INFO, 'INFO');
-    patch('error', api_logs_1.SeverityNumber.ERROR, 'ERROR');
-    patch('warn', api_logs_1.SeverityNumber.WARN, 'WARN');
-    patch('debug', api_logs_1.SeverityNumber.DEBUG, 'DEBUG');
-    console[PATCHED] = true;
-}