@forestadmin/agent-bff 1.31.0 → 1.33.0

package/dist/tracing.d.ts

@@ -0,0 +1,79 @@
+import type { Logger } from './ports/logger-port';
+/**
+ * The OpenTelemetry setup. `tracing-preload.ts` is what actually runs it, via `--require` before
+ * cli.js so the auto-instrumentation patches land before anything the app imports; keeping the two
+ * apart is what lets this module be imported by a test without arming an SDK.
+ *
+ * The SDK is initialised only when `OTEL_EXPORTER_OTLP_ENDPOINT` is set, so an install that never
+ * opted into APM pays nothing. Neither ending the process nor flushing on the way out is this
+ * module's business: it hands the SDK back, the preload parks it in `tracing-handle`, and the
+ * shutdown path flushes through that. Arming a signal handler here would consume a signal the CLI
+ * has not armed its own handler for yet, and nothing would then terminate the process.
+ * All configuration goes through the standard OTel environment variables:
+ *
+ *   OTEL_EXPORTER_OTLP_ENDPOINT   OTLP receiver (e.g. http://localhost:4318)
+ *   OTEL_SERVICE_NAME             default: forestadmin-agent-bff
+ *   OTEL_SDK_DISABLED             set to "true" to force-disable
+ *   OTEL_RESOURCE_ATTRIBUTES      e.g. deployment.environment=production
+ *   OTEL_METRICS_EXPORTER         default: none (the SDK's own default is otlp)
+ *   OTEL_LOGS_EXPORTER            default: none (the SDK's own default is otlp)
+ *
+ * The OTel packages are installed only into the Docker image's isolated deps (see
+ * `packages/agent-bff/docker/`), never shipped to npm consumers of the CLI — hence the dynamic
+ * require behind a seam, and the warning rather than a crash when they are absent.
+ */
+export declare const DEFAULT_SERVICE_NAME = "forestadmin-agent-bff";
+export interface OtelSdk {
+    start(): void;
+    shutdown(): Promise<void>;
+}
+export interface OtelModules {
+    NodeSDK: new (options: Record<string, unknown>) => OtelSdk;
+    getNodeAutoInstrumentations: () => unknown;
+}
+export interface TracingOptions {
+    /**
+     * The environment OUR decisions read: whether to arm at all, and what to name the service when
+     * nothing else does. It stops there — the SDK reads the real `process.env` for everything about
+     * the export itself, so a test injecting `env` cannot assert where spans go. Identical objects in
+     * production, so this is a limit on what the seam can test, not a behaviour.
+     */
+    env?: NodeJS.ProcessEnv;
+    logger?: Logger;
+    /** The dynamic require, as a seam: the packages exist only in the Docker image. */
+    load?: () => OtelModules | undefined;
+}
+/** The packages this image installs for APM, and the export it takes from each. */
+export declare const OTEL_MODULE_IDS: {
+    readonly sdk: "@opentelemetry/sdk-node";
+    readonly instrumentations: "@opentelemetry/auto-instrumentations-node";
+};
+/**
+ * The module resolution, as a seam. These packages are absent everywhere except the Docker image,
+ * so the real `require` can only ever take the failure branch here — passing a loader is what lets
+ * the success branch, and the package ids it asks for, be exercised at all. A typo in one of them
+ * would otherwise surface as an untraced image and nothing else.
+ */
+export type ModuleLoader = (id: string) => Record<string, unknown>;
+export declare function loadOtelModules(load?: ModuleLoader): OtelModules | undefined;
+/**
+ * The service name the environment already carries, by the spec's precedence: `OTEL_SERVICE_NAME`
+ * wins, then a `service.name` entry in the comma-separated `OTEL_RESOURCE_ATTRIBUTES` list.
+ * Undefined when neither names one, which is the only case where our own default should apply.
+ */
+export declare function serviceNameFromEnv(env: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Strips the credentials out of the endpoint before it reaches the logs. `https://user:token@host`
+ * is a legitimate way to reach a collector behind basic auth, and container logs are the last place
+ * that token should end up — this package does not echo a secret anywhere else either.
+ *
+ * The query string goes with them, unread: collectors that take their key as `?api_key=` exist, and
+ * telling them apart from a harmless parameter means knowing every vendor's spelling. Nothing about
+ * the destination is lost — the host and path are what the line is for.
+ *
+ * An endpoint that does not parse is dropped from the log entirely rather than passed through: it
+ * cannot be redacted, so it cannot be shown. The SDK will fail on it soon enough on its own.
+ */
+export declare function redactEndpoint(endpoint: string): string | undefined;
+export default function initTracing(options?: TracingOptions): OtelSdk | undefined;
+//# sourceMappingURL=tracing.d.ts.map

package/dist/tracing.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OTEL_MODULE_IDS = exports.DEFAULT_SERVICE_NAME = void 0;
+exports.loadOtelModules = loadOtelModules;
+exports.serviceNameFromEnv = serviceNameFromEnv;
+exports.redactEndpoint = redactEndpoint;
+exports.default = initTracing;
+const console_logger_1 = __importDefault(require("./adapters/console-logger"));
+/**
+ * The OpenTelemetry setup. `tracing-preload.ts` is what actually runs it, via `--require` before
+ * cli.js so the auto-instrumentation patches land before anything the app imports; keeping the two
+ * apart is what lets this module be imported by a test without arming an SDK.
+ *
+ * The SDK is initialised only when `OTEL_EXPORTER_OTLP_ENDPOINT` is set, so an install that never
+ * opted into APM pays nothing. Neither ending the process nor flushing on the way out is this
+ * module's business: it hands the SDK back, the preload parks it in `tracing-handle`, and the
+ * shutdown path flushes through that. Arming a signal handler here would consume a signal the CLI
+ * has not armed its own handler for yet, and nothing would then terminate the process.
+ * All configuration goes through the standard OTel environment variables:
+ *
+ *   OTEL_EXPORTER_OTLP_ENDPOINT   OTLP receiver (e.g. http://localhost:4318)
+ *   OTEL_SERVICE_NAME             default: forestadmin-agent-bff
+ *   OTEL_SDK_DISABLED             set to "true" to force-disable
+ *   OTEL_RESOURCE_ATTRIBUTES      e.g. deployment.environment=production
+ *   OTEL_METRICS_EXPORTER         default: none (the SDK's own default is otlp)
+ *   OTEL_LOGS_EXPORTER            default: none (the SDK's own default is otlp)
+ *
+ * The OTel packages are installed only into the Docker image's isolated deps (see
+ * `packages/agent-bff/docker/`), never shipped to npm consumers of the CLI — hence the dynamic
+ * require behind a seam, and the warning rather than a crash when they are absent.
+ */
+exports.DEFAULT_SERVICE_NAME = 'forestadmin-agent-bff';
+/** The packages this image installs for APM, and the export it takes from each. */
+exports.OTEL_MODULE_IDS = {
+    sdk: '@opentelemetry/sdk-node',
+    instrumentations: '@opentelemetry/auto-instrumentations-node',
+};
+function loadOtelModules(load = require) {
+    try {
+        const modules = {
+            NodeSDK: load(exports.OTEL_MODULE_IDS.sdk).NodeSDK,
+            getNodeAutoInstrumentations: load(exports.OTEL_MODULE_IDS.instrumentations)
+                .getNodeAutoInstrumentations,
+        };
+        // Resolving is not the same as finding what we came for. A package that loads but no longer
+        // exports the name we read — a rename on a version bump — would otherwise hand back a truthy
+        // object of undefined members, skip the "packages not available" branch, and throw a
+        // TypeError inside a `--require`, before the entry point runs at all. That is a dead container
+        // for an APM layer that is supposed to degrade to a warning.
+        if (Object.values(modules).some(exported => typeof exported !== 'function'))
+            return undefined;
+        return modules;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The OTel specification defines its boolean environment variables as case-insensitive, and this
+ * one is the kill switch: reading `TRUE` as "not disabled" would leave tracing running for someone
+ * who just asked for it to stop.
+ */
+function isDisabled(raw) {
+    return raw?.trim().toLowerCase() === 'true';
+}
+/**
+ * The service name the environment already carries, by the spec's precedence: `OTEL_SERVICE_NAME`
+ * wins, then a `service.name` entry in the comma-separated `OTEL_RESOURCE_ATTRIBUTES` list.
+ * Undefined when neither names one, which is the only case where our own default should apply.
+ */
+function serviceNameFromEnv(env) {
+    const explicit = env.OTEL_SERVICE_NAME?.trim();
+    if (explicit)
+        return explicit;
+    return env.OTEL_RESOURCE_ATTRIBUTES?.split(',')
+        .map(entry => entry.split('='))
+        .filter(([key, value]) => key?.trim() === 'service.name' && value?.trim())
+        .map(([, value]) => value.trim())
+        .pop();
+}
+/**
+ * Strips the credentials out of the endpoint before it reaches the logs. `https://user:token@host`
+ * is a legitimate way to reach a collector behind basic auth, and container logs are the last place
+ * that token should end up — this package does not echo a secret anywhere else either.
+ *
+ * The query string goes with them, unread: collectors that take their key as `?api_key=` exist, and
+ * telling them apart from a harmless parameter means knowing every vendor's spelling. Nothing about
+ * the destination is lost — the host and path are what the line is for.
+ *
+ * An endpoint that does not parse is dropped from the log entirely rather than passed through: it
+ * cannot be redacted, so it cannot be shown. The SDK will fail on it soon enough on its own.
+ */
+function redactEndpoint(endpoint) {
+    try {
+        const url = new URL(endpoint);
+        if (!url.username && !url.password && !url.search)
+            return endpoint;
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function initTracing(options = {}) {
+    const { env = process.env, logger = (0, console_logger_1.default)(), load = loadOtelModules } = options;
+    // Any of the three standard ways to say "export traces somewhere" turns tracing on. The per-signal
+    // endpoint counts as much as the generic one, and OTEL_TRACES_EXPORTER counts on its own —
+    // requiring an OTLP collector before `console` does anything would be nonsense for an exporter
+    // that writes to stdout, and it is the obvious first thing to reach for when debugging.
+    //
+    // A blank value counts as unset throughout, not as "export to the OTel default": `env_file` hands
+    // an empty string through for a variable left blank in a `.env`, and arming the SDK against
+    // localhost:4318 is not what leaving the line empty asks for.
+    const endpoint = env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim() || env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+    const requestedExporter = env.OTEL_TRACES_EXPORTER?.trim().toLowerCase();
+    if ((!endpoint && !requestedExporter) || isDisabled(env.OTEL_SDK_DISABLED))
+        return undefined;
+    const modules = load();
+    if (!modules) {
+        logger('Warn', 'OpenTelemetry packages not available, skipping APM initialisation');
+        return undefined;
+    }
+    const { NodeSDK, getNodeAutoInstrumentations } = modules;
+    // Passing `serviceName` unconditionally would override OTEL_RESOURCE_ATTRIBUTES=service.name=...,
+    // which is a documented knob — someone setting only that would silently get our default. So we
+    // fill it in only when the environment names no service at all, and otherwise leave the SDK to
+    // apply the spec's own precedence (OTEL_SERVICE_NAME first, then the resource attribute).
+    const named = serviceNameFromEnv(env);
+    // NodeSDK reads OTEL_METRICS_EXPORTER and OTEL_LOGS_EXPORTER itself, and an unset one does not
+    // mean "off" — it means otlp. So arming traces alone also starts a metric reader and a log
+    // processor aimed at the OTLP default, http://localhost:4318. Under OTEL_TRACES_EXPORTER=console,
+    // which asks for no collector at all, that is a POST every minute to a port nobody named; where
+    // something else on the host does listen there, it is telemetry that install never opted into.
+    // This module arms tracing. The other two signals stay opt-in, through their own variable, which
+    // still works: we only fill in what the environment left blank.
+    env.OTEL_METRICS_EXPORTER = env.OTEL_METRICS_EXPORTER?.trim() || 'none';
+    env.OTEL_LOGS_EXPORTER = env.OTEL_LOGS_EXPORTER?.trim() || 'none';
+    // No `traceExporter`, deliberately. Passing one puts NodeSDK on its manual-configuration path,
+    // where it stops reading the environment — which is how OTEL_TRACES_EXPORTER, then
+    // OTEL_EXPORTER_OTLP_PROTOCOL, then the per-signal endpoint each turned out to be silently
+    // ignored, one review round after another. They were three symptoms of doing the SDK's job.
+    //
+    // sdk-node depends on every OTLP exporter and on the Zipkin one, so all of them are in the image
+    // already; leaving the choice to the SDK costs nothing and makes the whole standard surface work,
+    // protocol and per-signal overrides included. Our only decisions are whether to arm at all, and
+    // the service name when nothing else supplies one.
+    const sdk = new NodeSDK({
+        ...(named ? {} : { serviceName: exports.DEFAULT_SERVICE_NAME }),
+        instrumentations: [getNodeAutoInstrumentations()],
+    });
+    sdk.start();
+    // What was ASKED for, not what the SDK settled on — we no longer choose, so claiming a
+    // destination we did not pick would be inventing one. The endpoint is dropped when an exporter
+    // was named instead, since it would read as a promise this line cannot keep.
+    logger('Info', 'OpenTelemetry tracing enabled', {
+        serviceName: named ?? exports.DEFAULT_SERVICE_NAME,
+        ...(requestedExporter ? { exporter: requestedExporter } : {}),
+        ...(endpoint && !requestedExporter ? { endpoint: redactEndpoint(endpoint) } : {}),
+    });
+    return sdk;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/agent-bff",
-  "version": "1.31.0",
+  "version": "1.33.0",
   "main": "dist/index.js",
   "bin": {
     "forest-bff": "dist/cli.js"