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

package/README.md

@@ -160,19 +160,43 @@ exporters. Note: Never add Foam's own processors/readers helpers.
 `additionalResourceAttributes` adds extra resource attributes (for example
 `team` or `cloud.region`) to all telemetry.
 
-`disableLogSending` defaults to `false`. Set `true` to stop copying logger
-records into Foam (see Loggers).
+`disableLogSending` defaults to `false`. Set `true` to stop Foam from
+adding its own sending path to supported loggers; trace correlation in
+log records is unaffected (see Loggers).
 
 `networkCapture` defaults to `"basic"`. Upgrade to `"advanced"` unless you
 cannot; it gives much more powerful HTTP and Undici capture. See Network capture.
 
-`redact` and `beforeSend` are accepted but **not implemented yet**; passing
-them logs a warning and they are ignored. `redact` will add extra
-sensitive keys (strings or RegExps) to the built-in body redaction list.
-`beforeSend` will run on every captured body before it leaves the
-process, returning the (possibly edited) text or `null` to drop the
-capture. Until they ship, rely on the built-in redaction (see Network
-capture).
+`redact` adds keys to Foam's built-in redaction. `secrets` preserves the last
+four characters of longer values; `pii` fully masks values.
+
+```js
+init({
+  // ...
+  redact: {
+    secrets: ["internalId", "internalReference"],
+    pii: ["customerEmail", "homeAddress"],
+  },
+});
+```
+
+`beforeSend` can edit or drop spans and logs before Foam exports them. Return
+the event to send it or `null` to drop it.
+
+```js
+init({
+  // ...
+  beforeSend: (event) => {
+    if (event.type === "span" && event.attributes["url.path"] === "/health") {
+      return null; // drop health checks
+    }
+    delete event.attributes["user.email"];
+    return event;
+  },
+});
+```
+
+Metrics are not passed through `beforeSend`. See Redaction for coverage.
 
 `ignoredOutboundHosts` skips outbound HTTP tracing for those hostnames.
 The configured `endpoint` host is always skipped so export calls do not
@@ -185,15 +209,18 @@ TODO(pcga11): Add other common Gen AI providers.
 If another SDK already registered traces, metrics, logs, or the propagator,
 `init()` leaves the signal's slot untouched and only takes what is available. When a slot is taken, use its ingest helper instead.
 
-### `createFoamIngestSpanProcessor(name, environment, token)`
+### `createFoamIngestSpanProcessor(name, environment, token, options?)`
 
-Returns a span processor that exports traces to Foam without taking over
-the global TracerProvider.
-
-Use this when another OpenTelemetry SDK already owns traces and you only
-need Foam as an extra export destination.
+The helper returns a span processor but does not attach it to the
+application's provider. Include it in the `spanProcessors` option when
+constructing `BasicTracerProvider`. It cannot be added after provider
+construction in `@opentelemetry/sdk-trace-base` 2.10; the old
+`addSpanProcessor()` API is obsolete. If another SDK creates the provider,
+configure the processor through that SDK's startup options.
 
 ```js
+import { trace } from "@opentelemetry/api";
+import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
 import { createFoamIngestSpanProcessor } from "@foam-ai/node";
 
 const spanProcessor = createFoamIngestSpanProcessor(
@@ -201,18 +228,24 @@ const spanProcessor = createFoamIngestSpanProcessor(
   "production",
   process.env.FOAM_OTEL_TOKEN,
 );
-tracerProvider.addSpanProcessor(spanProcessor);
+const tracerProvider = new BasicTracerProvider({
+  spanProcessors: [spanProcessor],
+});
+trace.setGlobalTracerProvider(tracerProvider);
 ```
 
-### `createFoamIngestLogRecordProcessor(name, environment, token)`
+### `createFoamIngestLogRecordProcessor(name, environment, token, options?)`
 
-Returns a log-record processor that exports logs to Foam without taking over
-the global LoggerProvider.
-
-Use this when another SDK already owns logs and you want those records in
-Foam.
+The helper returns a log-record processor but does not attach it to the
+application's provider. Include it in the `processors` option when constructing
+`LoggerProvider`. It cannot be added after provider construction in
+`@opentelemetry/sdk-logs` 0.221; the old `addLogRecordProcessor()` API is
+obsolete. If another SDK creates the provider, configure the processor through
+that SDK's startup options.
 
 ```js
+import { logs } from "@opentelemetry/api-logs";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
 import { createFoamIngestLogRecordProcessor } from "@foam-ai/node";
 
 const logRecordProcessor = createFoamIngestLogRecordProcessor(
@@ -220,18 +253,27 @@ const logRecordProcessor = createFoamIngestLogRecordProcessor(
   "production",
   process.env.FOAM_OTEL_TOKEN,
 );
-loggerProvider.addLogRecordProcessor(logRecordProcessor);
+const loggerProvider = new LoggerProvider({
+  processors: [logRecordProcessor],
+});
+logs.setGlobalLoggerProvider(loggerProvider);
 ```
 
-### `createFoamIngestMetricReader(name, environment, token)`
+Both ingest helpers accept the same `redact` and `beforeSend` options as
+`init()`.
 
-Returns a metric reader that exports metrics to Foam without taking over
-the global MeterProvider.
+### `createFoamIngestMetricReader(name, environment, token)`
 
-Use this when another SDK already owns metrics and you want those meters in
-Foam.
+The helper returns a metric reader but does not attach it to the application's
+provider. Include it in the `readers` option when constructing `MeterProvider`.
+It cannot be added after provider construction in
+`@opentelemetry/sdk-metrics` 2.10; the old `addMetricReader()` API is obsolete.
+If another SDK creates the provider, configure the reader through that SDK's
+startup options.
 
 ```js
+import { metrics } from "@opentelemetry/api";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
 import { createFoamIngestMetricReader } from "@foam-ai/node";
 
 const metricReader = createFoamIngestMetricReader(
@@ -239,9 +281,15 @@ const metricReader = createFoamIngestMetricReader(
   "production",
   process.env.FOAM_OTEL_TOKEN,
 );
-meterProvider.addMetricReader(metricReader);
+const meterProvider = new MeterProvider({
+  readers: [metricReader],
+});
+metrics.setGlobalMeterProvider(meterProvider);
 ```
 
+If a vendor SDK does not expose a processor or reader startup option, add Foam
+at the collector instead.
+
 If the other SDK already set `service.name` or environment,
 Foam's values overwrite them on that copy only. The original spans, logs,
 and metrics are left unchanged. For the Foam SDK, ensure all of the signals (spans, logs and metrics)
@@ -275,7 +323,7 @@ OpenTelemetry allows only one global propagator per signal. Foam registers W3C T
 Context and W3C Baggage (`traceparent`, `tracestate`, `baggage`), not B3,
 Jaeger, or AWS X-Ray. Auto-instrumented HTTP uses whichever propagator
 won. If another SDK already registered a propagator, Foam keeps it and
-`getState().signals.baggage` is `false`. A non-W3C propagator will not
+`getState().signals.baggage` is `"none"`. A non-W3C propagator will not
 send `traceparent`, so a Foam peer starts a new trace. Foam does not add
 W3C headers on top.
 
@@ -304,7 +352,8 @@ await kafka.send({ value: payload, headers });
 Reads W3C trace and baggage headers and returns a parent OpenTelemetry
 context.
 
-Use this when you receive a message on a custom transport so the tracing carries over. Missing to extact resets the context on these headers effectively losing the context previously injected.
+Use this when receiving a message on a custom transport. Without extraction,
+the handler loses the propagated parent context.
 
 ```js
 import { context } from "@opentelemetry/api";
@@ -313,18 +362,14 @@ const parent = extractTraceContext(message.headers);
 await context.with(parent, () => handle(message));
 ```
 
-### `setBaggage(key, value)`
+### `setBaggage(key, value, callback)`
 
-Stores a small string on the current request context.
-
-Use this for request-scoped identity (tenant, user id) that should follow
-the request across `await`s without being passed through every function.
-
-Values do not leak to other concurrent requests. Caveat: auto-instrumented HTTP
-does not send these keys until you call `injectTraceContext`.
+Runs a callback with a request-scoped string such as a tenant or user ID.
+The value follows work started by the callback across `await`s without leaking
+to later handlers. Call `injectTraceContext` to send it on custom transports.
 
 ```js
-setBaggage("tenant.id", "acme");
+await setBaggage("tenant.id", "acme", () => handleRequest());
 ```
 
 ### `getBaggage(key)`
@@ -524,42 +569,51 @@ export wherever `getState().signals.traces` points.
 - `"advanced"` adds those headers plus full Node `http`/`https` and
   Fetch/Undici request and response bodies as raw wire bytes, up to 1 MiB. Always set to `"advanced"` when security and compliance allows.
 
+## Redaction
 
-Headers are captured from an allowlist only, so sensitive headers such as
-`authorization` and `cookie` never leave the process. Captured JSON and
-form-urlencoded bodies are redacted before emission: values of sensitive
-keys (`password`, `token`, `api_key`, `client_secret`, `ssn`, and similar,
-matched case-insensitively across `-`, `_`, and `.` separators) are
-replaced with `[REDACTED]` on both the span body content and the emitted
-body chunks. When redaction changes a compressed body, the chunks carry
-the redacted text instead of the raw wire bytes. Other text and binary
-media types are captured unmodified.
-
-## Loggers
-
-Foam follows the compatibility ranges of its OpenTelemetry logger
-instrumentations:
-
-- Bunyan `>=1 <2`
-- Pino `>=5.14 <11`
-- Winston `>=1 <4`
-
-Initialize Foam before you import or construct the logger. Registration alone does not mean a logger
-was loaded, patched, or produced records.
-
-With `disableLogSending: false` (the default), Foam SDK sends:
+Foam always masks common credentials in captured request and response data,
+URLs, and exported span and log fields. Add application-specific keys with the
+`redact` option shown under `init(options)`.
 
-- Bunyan 1 records through an added OTel stream
-- Pino 7–10 records through an added main-thread `multistream`
-- Winston 3 records through the bundled `OpenTelemetryTransportV3`
+Redaction applies to Foam's exports, including ingest helpers. It does not
+modify telemetry sent through other exporters.
 
-Pino 5–6 and Winston 1–2 still get correlation. But they have no sending
-path (`pino.multistream` starts at 7; Winston transports start at 3), so Foam never receives a copy. Call `log()` to send a record yourself.
+## Loggers
 
-Set `disableLogSending: true` when the app already exports logger records
-itself (a Bunyan OTel stream, `pino-opentelemetry-transport`, a Winston
-OTel transport, or another pipeline). That turns off sending for Bunyan
-1, Pino 7–10, and Winston 3.
+Initialize Foam before you import or construct the logger.
+
+What Foam does depends on the logger version:
+
+- Bunyan 1, Pino 7–10, and Winston 3: Foam adds trace IDs to every
+  record and automatically sends a copy to Foam.
+- Pino 5.14–6 and Winston 1–2: Foam adds trace IDs, but these versions
+  have no way to attach a sender, so no copy reaches Foam. Upgrade the
+  logger, or call `log()` yourself.
+- Everything else: Foam does nothing. Use `console.*` (captured
+  below), call `log()`, or upgrade the logger.
+
+### If the app already ships logs somewhere
+
+- To a non-OTel destination (files, another vendor's transport): no
+  conflict. Keep the defaults; Foam sends its own copy alongside.
+- Through its own OTel stream/transport (a Bunyan OTel stream,
+  Winston `OpenTelemetryTransportV3`): those already deliver to Foam
+  via the global LoggerProvider. Set `disableLogSending: true` so
+  records don't arrive twice.
+- Through another OTel SDK's LoggerProvider: set
+  `disableLogSending: true` and attach
+  `createFoamIngestLogRecordProcessor` to that provider (see Public
+  API) so Foam gets a copy.
+- Through `pino-opentelemetry-transport`: it runs in a worker
+  thread and never touches the in-process LoggerProvider, so nothing
+  conflicts. Keep `disableLogSending: false`, or Foam gets no Pino
+  records at all.
+- Through a collector or agent reading stdout/files: no app changes;
+  add a Foam OTLP exporter to the collector config.
+
+`log()` sends a single record straight to Foam in any setup. It is a
+manual per-record call, not a mirror of the logger. Use it for
+targeted, high-value records.
 
 `ConsoleInstrumentation` turns calls to `console.*` into OTel log records.
 It does not capture arbitrary stdout/stderr writes.
@@ -584,3 +638,12 @@ The official OpenTelemetry JavaScript SDK has no in-process Profiles provider, p
 - [Profiling SIG language SDK support tracker](https://github.com/open-telemetry/sig-profiling/issues/106)
 - [OpenTelemetry Profiles public alpha announcement](https://opentelemetry.io/blog/2026/profiles-alpha/)
 - [OpenTelemetry eBPF profiler](https://github.com/open-telemetry/opentelemetry-ebpf-profiler)
+
+## TODO(pcga11): Anthropic instrumentation
+
+There is no released official OpenTelemetry JavaScript instrumentation for the Anthropic SDK yet, but one is actively in progress in js-contrib, based on the OpenInference donation from Arize. Once `@opentelemetry/instrumentation-anthropic` is released (and picked up by `auto-instrumentations-node`), bundle it here like the OpenAI and aws-sdk ones. Until then, Anthropic coverage is handled case by case with the FDE (see FDE.md). Track upstream progress:
+
+- [feat(instrumentation-anthropic): add basic messages instrumentation](https://github.com/open-telemetry/opentelemetry-js-contrib/pull/3664)
+- [refactor(instrumentation-anthropic): use genai-util library](https://github.com/open-telemetry/opentelemetry-js-contrib/pull/3698)
+- [Tracking: Migrate OpenInference JS instrumentations into opentelemetry-js-contrib](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3668)
+- [feat: Add @opentelemetry/genai-util package for GenAI instrumentations](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3681)

package/dist/before-send.d.ts

@@ -0,0 +1,16 @@
+interface BeforeSendSpanEvent {
+    readonly type: "span";
+    name: string;
+    attributes: Record<string, unknown>;
+}
+interface BeforeSendLogEvent {
+    readonly type: "log";
+    body?: unknown;
+    severityText?: string;
+    attributes: Record<string, unknown>;
+}
+export type BeforeSendEvent = BeforeSendSpanEvent | BeforeSendLogEvent;
+export type BeforeSendHook = (event: BeforeSendEvent) => BeforeSendEvent | null;
+export declare function resolveBeforeSend(hook: unknown): BeforeSendHook | undefined;
+export declare function invokeBeforeSend(hook: BeforeSendHook, event: BeforeSendEvent): BeforeSendEvent | null | undefined;
+export {};

package/dist/before-send.js

@@ -0,0 +1,41 @@
+"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";
+    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

@@ -1,9 +1,10 @@
 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.7";
+export declare const FOAM_DISTRO_VERSION = "0.1.0-alpha.5";
 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";
@@ -37,7 +38,7 @@ export declare const ATTR_FOAM_HTTP_REQUEST_BODY_TRUNCATED = "foam.http.request.
 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 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

@@ -1,12 +1,13 @@
 "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;
+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.7";
+exports.FOAM_DISTRO_VERSION = "0.1.0-alpha.5";
 exports.FOAM_OTLP_TRACES_PATH = "/v1/traces";
 exports.FOAM_OTLP_LOGS_PATH = "/v1/logs";
 exports.FOAM_OTLP_METRICS_PATH = "/v1/metrics";
@@ -53,39 +54,8 @@ exports.SAFE_NETWORK_HEADERS = [
     "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.FULL_MASK = "********";
+exports.TAIL_MASK_THRESHOLD = 12;
 exports.DIAG_LOG_LEVEL = "OTEL_LOG_LEVEL";
 exports.SEVERITY_TEXT = {
     [api_logs_1.SeverityNumber.TRACE]: "TRACE",

package/dist/exporters.d.ts

@@ -1,20 +1,28 @@
 import type { Attributes } from "@opentelemetry/api";
-import type { ExportResult } from "@opentelemetry/core";
+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?;
-    constructor(token: string, stamp?: 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?;
-    constructor(token: string, stamp?: 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 {