@frontmcp/observability 0.0.1 → 1.0.0

package/esm/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@frontmcp/observability",
+  "version": "1.0.0",
+  "description": "OpenTelemetry instrumentation, structured JSON logging, and request log objects for FrontMCP",
+  "author": "AgentFront <info@agentfront.dev>",
+  "license": "Apache-2.0",
+  "keywords": [
+    "opentelemetry",
+    "otel",
+    "observability",
+    "tracing",
+    "structured-logging",
+    "json-logging",
+    "request-log",
+    "mcp",
+    "frontmcp",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentfront/frontmcp.git",
+    "directory": "libs/observability"
+  },
+  "bugs": {
+    "url": "https://github.com/agentfront/frontmcp/issues"
+  },
+  "homepage": "https://github.com/agentfront/frontmcp/blob/main/libs/observability/README.md",
+  "type": "module",
+  "main": "../index.js",
+  "module": "./index.mjs",
+  "types": "../index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "../package.json",
+    ".": {
+      "require": {
+        "types": "../index.d.ts",
+        "default": "../index.js"
+      },
+      "import": {
+        "types": "../index.d.ts",
+        "default": "./index.mjs"
+      }
+    },
+    "./esm": null
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0"
+  },
+  "peerDependencies": {
+    "@frontmcp/sdk": "^1.0.0-beta.13",
+    "@frontmcp/utils": "^1.0.0-beta.13",
+    "@opentelemetry/sdk-trace-base": "^1.25.0",
+    "@opentelemetry/sdk-node": "^0.52.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.52.0",
+    "winston": "^3.0.0",
+    "pino": "^8.0.0 || ^9.0.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
+    },
+    "@opentelemetry/sdk-node": {
+      "optional": true
+    },
+    "@opentelemetry/exporter-trace-otlp-http": {
+      "optional": true
+    },
+    "winston": {
+      "optional": true
+    },
+    "pino": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.0.0",
+    "zod": "^4.0.0",
+    "@opentelemetry/sdk-trace-base": "^1.25.0"
+  }
+}

package/index.d.ts

@@ -0,0 +1,11 @@
+export { ObservabilityPlugin, sessionTracingId, reportStartup } from './plugin';
+export type { ObservabilityPluginOptions, ObservabilityPluginOptionsInput, ObservabilityLoggingOptions, } from './plugin';
+export { McpAttributes, FrontMcpAttributes, HttpAttributes, RpcAttributes, EnduserAttributes, OTEL_TRACER, OTEL_CONFIG, frontmcpToOTelSpanContext, otelToFrontmcpContext, createOTelContextFromTrace, FrontMcpPropagator, setupOTel, startSpan, endSpanOk, endSpanError, withSpan, startHttpServerSpan, setHttpResponseStatus, startRpcSpan, startToolSpan, startResourceSpan, startPromptSpan, recordHookEvent, startHookSpan, startFetchSpan, setFetchResponseStatus, startTransportSpan, setTransportRequestType, startAuthSpan, setAuthMode, setAuthResult, emitStartupReport, PrettySpanExporter, } from './otel';
+export type { TracingOptions, OTelSetupOptions, TraceContextLike, StartSpanOptions, HttpServerSpanOptions, RpcSpanOptions, ToolSpanOptions, ResourceSpanOptions, PromptSpanOptions, HookSpanOptions, FetchSpanOptions, TransportSpanOptions, AuthSpanOptions, StartupTelemetryData, } from './otel';
+export { StructuredLogTransport, LOG_LEVEL_TO_OTEL_SEVERITY, StdoutSink, ConsoleSink, WinstonSink, PinoSink, CallbackSink, OtlpSink, createSink, createSinks, redactFields, } from './logging';
+export type { StructuredLogEntry, StructuredLogError, StructuredLogTransportOptions, LogSink, SinkConfig, StdoutSinkConfig, ConsoleSinkConfig, WinstonSinkConfig, PinoSinkConfig, CallbackSinkConfig, OtlpSinkConfig, OtlpSinkOptions, WinstonLike, PinoLike, ContextAccessor, ContextSnapshot, } from './logging';
+export { TelemetryAccessor, TelemetrySpan, TELEMETRY_ACCESSOR } from './telemetry';
+export { createTestTracer, getFinishedSpans, assertSpanExists, assertSpanAttribute, findSpan, findSpansByAttribute, } from './testing';
+export type { TestTracer } from './testing';
+export { RequestLogCollector, REQUEST_LOG_COLLECTOR } from './request-log';
+export type { RequestLog, RequestLogEntry, RequestLogCollectorOptions } from './request-log';

package/logging/index.d.ts

@@ -0,0 +1,9 @@
+export type { StructuredLogEntry, StructuredLogError, StructuredLogTransportOptions } from './structured-log.types';
+export { LOG_LEVEL_TO_OTEL_SEVERITY } from './structured-log.types';
+export type { LogSink, SinkConfig, StdoutSinkConfig, ConsoleSinkConfig, WinstonSinkConfig, PinoSinkConfig, CallbackSinkConfig, OtlpSinkConfig, WinstonLike, PinoLike, } from './log-sink.interface';
+export { StructuredLogTransport } from './structured-log-transport';
+export type { ContextAccessor, ContextSnapshot } from './structured-log-transport';
+export { StdoutSink, ConsoleSink, WinstonSink, PinoSink, CallbackSink, OtlpSink } from './sinks';
+export type { OtlpSinkOptions } from './sinks';
+export { createSink, createSinks } from './sink.factory';
+export { redactFields } from './redaction';

package/logging/log-sink.interface.d.ts

@@ -0,0 +1,81 @@
+import type { StructuredLogEntry } from './structured-log.types';
+/**
+ * LogSink — pluggable output adapter for structured log entries.
+ *
+ * Implementations determine where and how log objects are written:
+ * - StdoutSink: NDJSON to process.stdout (12-factor)
+ * - ConsoleSink: console.log/warn/error (browser-safe)
+ * - WinstonSink: forward to winston logger instance
+ * - PinoSink: forward to pino logger instance
+ * - CallbackSink: user-provided callback function
+ */
+export interface LogSink {
+    /** Write a structured log entry to the output */
+    write(entry: StructuredLogEntry): void;
+    /** Optional: flush buffered entries */
+    flush?(): Promise<void>;
+    /** Optional: cleanup resources */
+    close?(): Promise<void>;
+}
+/**
+ * Sink configuration — discriminated union for built-in sink types.
+ */
+export type SinkConfig = StdoutSinkConfig | ConsoleSinkConfig | WinstonSinkConfig | PinoSinkConfig | CallbackSinkConfig | OtlpSinkConfig;
+export interface StdoutSinkConfig {
+    type: 'stdout';
+    /** Writable stream override (default: process.stdout) */
+    stream?: NodeJS.WritableStream;
+    /** Pretty-print JSON (default: false) */
+    pretty?: boolean;
+}
+export interface ConsoleSinkConfig {
+    type: 'console';
+}
+export interface WinstonSinkConfig {
+    type: 'winston';
+    /** Winston logger instance */
+    logger: WinstonLike;
+}
+export interface PinoSinkConfig {
+    type: 'pino';
+    /** Pino logger instance */
+    logger: PinoLike;
+}
+export interface CallbackSinkConfig {
+    type: 'callback';
+    /** User-provided callback */
+    fn: (entry: StructuredLogEntry) => void;
+}
+export interface OtlpSinkConfig {
+    type: 'otlp';
+    /** OTLP endpoint (e.g., 'http://localhost:4318'). Path '/v1/logs' is appended. */
+    endpoint?: string;
+    /** Custom headers (for auth tokens, API keys) */
+    headers?: Record<string, string>;
+    /** Max batch size before auto-flush (default: 100) */
+    batchSize?: number;
+    /** Flush interval in ms (default: 5000) */
+    flushIntervalMs?: number;
+    /** Service name for resource identification */
+    serviceName?: string;
+}
+/**
+ * Minimal winston-compatible logger interface.
+ * Avoids hard dependency on winston types.
+ */
+export interface WinstonLike {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+/**
+ * Minimal pino-compatible logger interface.
+ * Avoids hard dependency on pino types.
+ */
+export interface PinoLike {
+    debug(obj: Record<string, unknown>, msg?: string): void;
+    info(obj: Record<string, unknown>, msg?: string): void;
+    warn(obj: Record<string, unknown>, msg?: string): void;
+    error(obj: Record<string, unknown>, msg?: string): void;
+}

package/logging/redaction.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Field redaction utilities for structured log entries.
+ *
+ * Traverses objects and replaces values of sensitive fields with '[REDACTED]'.
+ */
+/**
+ * Redact sensitive fields from an object.
+ *
+ * Performs a shallow clone with redacted values — does not mutate the input.
+ * Field matching is case-insensitive.
+ *
+ * @param obj - Object to redact fields from
+ * @param fields - Field names to redact (case-insensitive)
+ * @param maxDepth - Maximum recursion depth (default: 5)
+ * @returns New object with sensitive fields replaced by '[REDACTED]'
+ */
+export declare function redactFields(obj: Record<string, unknown>, fields: string[], maxDepth?: number): Record<string, unknown>;

package/logging/sink.factory.d.ts

@@ -0,0 +1,15 @@
+import type { LogSink, SinkConfig } from './log-sink.interface';
+/**
+ * Create a LogSink from a SinkConfig.
+ *
+ * Winston and Pino sinks are instantiated inline to avoid
+ * bundling their types when not used.
+ */
+export declare function createSink(config: SinkConfig): LogSink;
+/**
+ * Create an array of LogSink instances from an array of SinkConfig.
+ *
+ * If no configs are provided, defaults to StdoutSink in Node.js
+ * or ConsoleSink in browser environments.
+ */
+export declare function createSinks(configs?: SinkConfig[]): LogSink[];

package/logging/sinks/callback.sink.d.ts

@@ -0,0 +1,12 @@
+import type { LogSink } from '../log-sink.interface';
+import type { StructuredLogEntry } from '../structured-log.types';
+/**
+ * CallbackSink — forwards structured log entries to a user-provided function.
+ *
+ * Useful for custom integrations, testing, or forwarding to queues/streams.
+ */
+export declare class CallbackSink implements LogSink {
+    private readonly fn;
+    constructor(fn: (entry: StructuredLogEntry) => void);
+    write(entry: StructuredLogEntry): void;
+}

package/logging/sinks/console.sink.d.ts

@@ -0,0 +1,16 @@
+import type { LogSink } from '../log-sink.interface';
+import type { StructuredLogEntry } from '../structured-log.types';
+/**
+ * ConsoleSink — writes structured log entries to the console.
+ *
+ * Simple one-liner format with trace context. Use this sink when you want
+ * telemetry data in the console (e.g., browser, or when the SDK console
+ * logger is disabled).
+ *
+ * For typical development, you don't need this sink — the SDK's built-in
+ * console logger handles dev output. The telemetry pipeline runs separately
+ * via StructuredLogTransport and its configured sinks (stdout, otlp, callback).
+ */
+export declare class ConsoleSink implements LogSink {
+    write(entry: StructuredLogEntry): void;
+}

package/logging/sinks/index.d.ts

@@ -0,0 +1,7 @@
+export { StdoutSink } from './stdout.sink';
+export { ConsoleSink } from './console.sink';
+export { WinstonSink } from './winston.sink';
+export { PinoSink } from './pino.sink';
+export { CallbackSink } from './callback.sink';
+export { OtlpSink } from './otlp.sink';
+export type { OtlpSinkOptions } from './otlp.sink';

package/logging/sinks/otlp.sink.d.ts

@@ -0,0 +1,67 @@
+/**
+ * OtlpSink — exports structured log entries via OTLP HTTP to any
+ * OTel-compatible backend (Coralogix, Datadog, Logz.io, Grafana, etc.).
+ *
+ * Posts to `{endpoint}/v1/logs` using the OTel Logs data model.
+ * Batches entries and flushes periodically or on demand.
+ *
+ * @example
+ * ```typescript
+ * // Coralogix
+ * { type: 'otlp', endpoint: 'https://ingress.coralogix.com:443',
+ *   headers: { Authorization: 'Bearer CX_API_KEY' } }
+ *
+ * // Datadog
+ * { type: 'otlp', endpoint: 'https://http-intake.logs.datadoghq.com',
+ *   headers: { 'DD-API-KEY': 'YOUR_KEY' } }
+ *
+ * // Logz.io
+ * { type: 'otlp', endpoint: 'https://otlp-listener.logz.io:8071',
+ *   headers: { Authorization: 'Bearer SHIPPING_TOKEN' } }
+ *
+ * // Local OTLP collector
+ * { type: 'otlp', endpoint: 'http://localhost:4318' }
+ * ```
+ */
+import type { LogSink } from '../log-sink.interface';
+import type { StructuredLogEntry } from '../structured-log.types';
+export interface OtlpSinkOptions {
+    /** OTLP endpoint (e.g., 'http://localhost:4318'). Path '/v1/logs' is appended. */
+    endpoint: string;
+    /** Custom headers (for auth tokens, API keys) */
+    headers?: Record<string, string>;
+    /** Max batch size before auto-flush (default: 100) */
+    batchSize?: number;
+    /** Max queue capacity — oldest entries are dropped when exceeded (default: 5000) */
+    maxQueueSize?: number;
+    /** Flush interval in ms (default: 5000) */
+    flushIntervalMs?: number;
+    /** Service name for resource identification */
+    serviceName?: string;
+}
+/**
+ * OtlpSink — batches structured log entries and exports via OTLP HTTP.
+ */
+export declare class OtlpSink implements LogSink {
+    private batch;
+    private readonly endpoint;
+    private readonly headers;
+    private readonly batchSize;
+    private readonly maxQueueSize;
+    private readonly serviceName;
+    private flushTimer?;
+    constructor(options: OtlpSinkOptions);
+    write(entry: StructuredLogEntry): void;
+    flush(): Promise<void>;
+    private requeue;
+    private enforceCapacity;
+    close(): Promise<void>;
+    /**
+     * Build OTLP Logs JSON payload per the OTel spec.
+     *
+     * @see https://opentelemetry.io/docs/specs/otlp/#otlphttp-request
+     * @see https://opentelemetry.io/docs/specs/otel/logs/data-model/
+     */
+    private buildOtlpPayload;
+    private entryToLogRecord;
+}

package/logging/sinks/pino.sink.d.ts

@@ -0,0 +1,13 @@
+import type { LogSink, PinoLike } from '../log-sink.interface';
+import type { StructuredLogEntry } from '../structured-log.types';
+/**
+ * PinoSink — forwards structured log entries to a pino logger.
+ *
+ * Pino uses the signature `logger.info(obj, msg)` where the object
+ * comes first, so we pass the entry fields as the merge object.
+ */
+export declare class PinoSink implements LogSink {
+    private readonly logger;
+    constructor(logger: PinoLike);
+    write(entry: StructuredLogEntry): void;
+}

package/logging/sinks/stdout.sink.d.ts

@@ -0,0 +1,17 @@
+import type { LogSink } from '../log-sink.interface';
+import type { StructuredLogEntry } from '../structured-log.types';
+/**
+ * StdoutSink — writes NDJSON (newline-delimited JSON) to process.stdout.
+ *
+ * 12-factor compliant: logs are written as a stream of events to stdout,
+ * ready for collection by Docker, K8s, CloudWatch, or any log aggregator.
+ */
+export declare class StdoutSink implements LogSink {
+    private readonly stream;
+    private readonly pretty;
+    constructor(options?: {
+        stream?: NodeJS.WritableStream;
+        pretty?: boolean;
+    });
+    write(entry: StructuredLogEntry): void;
+}

package/logging/sinks/winston.sink.d.ts

@@ -0,0 +1,13 @@
+import type { LogSink, WinstonLike } from '../log-sink.interface';
+import type { StructuredLogEntry } from '../structured-log.types';
+/**
+ * WinstonSink — forwards structured log entries to a winston logger.
+ *
+ * Maps FrontMCP log levels to winston levels and passes the full
+ * entry object as metadata so winston formatters can access all fields.
+ */
+export declare class WinstonSink implements LogSink {
+    private readonly logger;
+    constructor(logger: WinstonLike);
+    write(entry: StructuredLogEntry): void;
+}

package/logging/structured-log-transport.d.ts

@@ -0,0 +1,52 @@
+import { LogTransportInterface, LogRecord } from '@frontmcp/sdk';
+import type { LogSink } from './log-sink.interface';
+import type { StructuredLogEntry, StructuredLogTransportOptions } from './structured-log.types';
+/**
+ * Context accessor function type.
+ *
+ * The transport calls this to get the current FrontMcpContext
+ * from AsyncLocalStorage. Returns undefined when outside a request.
+ */
+export interface ContextAccessor {
+    (): ContextSnapshot | undefined;
+}
+/**
+ * Minimal context snapshot — avoids importing the full FrontMcpContext type.
+ * Extracted by the plugin from FrontMcpContextStorage.getStore().
+ */
+export interface ContextSnapshot {
+    requestId: string;
+    traceContext: {
+        traceId: string;
+        parentId: string;
+        traceFlags: number;
+    };
+    sessionIdHash: string;
+    scopeId: string;
+    flowName?: string;
+    elapsed: number;
+}
+/**
+ * StructuredLogTransport — bridges SDK logger → structured log objects → sinks.
+ *
+ * This is a LogTransportInterface implementation that:
+ * 1. Receives LogRecord from the SDK logger
+ * 2. Reads FrontMcpContext (if available) for trace correlation
+ * 3. Builds a StructuredLogEntry object
+ * 4. Applies field redaction
+ * 5. Forwards to all registered LogSink instances
+ */
+export declare class StructuredLogTransport extends LogTransportInterface {
+    private readonly sinks;
+    private readonly redactFieldNames;
+    private readonly includeStacks;
+    private readonly staticFields;
+    private readonly getContext;
+    /** Optional listener for request log collection */
+    onEntry?: (entry: StructuredLogEntry) => void;
+    constructor(sinks: LogSink[], options?: StructuredLogTransportOptions, contextAccessor?: ContextAccessor);
+    log(rec: LogRecord): void;
+    private buildEntry;
+    private processArgs;
+    private buildError;
+}

package/logging/structured-log.types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Structured log entry — the core log object.
+ *
+ * Every log entry produced by StructuredLogTransport is a plain
+ * StructuredLogEntry object. Output adapters (sinks) serialize
+ * it for their target (NDJSON → stdout, winston → winston transport, etc.).
+ */
+export interface StructuredLogEntry {
+    /** ISO 8601 timestamp (e.g., "2026-03-31T14:22:05.123Z") */
+    timestamp: string;
+    /** Log level name */
+    level: 'debug' | 'verbose' | 'info' | 'warn' | 'error';
+    /** OTel severity number (1–24) for log correlation */
+    severity_number: number;
+    /** Log message */
+    message: string;
+    /** W3C trace ID (32 hex chars) — from FrontMcpContext */
+    trace_id?: string;
+    /** OTel span ID (16 hex chars) — from FrontMcpContext.traceContext.parentId */
+    span_id?: string;
+    /** W3C trace flags */
+    trace_flags?: number;
+    /** Unique request identifier — from FrontMcpContext */
+    request_id?: string;
+    /** SHA-256 truncated session ID (12 chars) — from FrontMcpContext */
+    session_id_hash?: string;
+    /** Scope identifier — from FrontMcpContext */
+    scope_id?: string;
+    /** Current flow name — from FrontMcpContext */
+    flow_name?: string;
+    /** Logger child prefix chain */
+    prefix?: string;
+    /** Error details (populated when level = error and args contain an Error) */
+    error?: StructuredLogError;
+    /** Elapsed time since request start in milliseconds */
+    elapsed_ms?: number;
+    /** Structured attributes extracted from log args */
+    attributes?: Record<string, unknown>;
+}
+/**
+ * Structured error information.
+ */
+export interface StructuredLogError {
+    /** Error class name */
+    type: string;
+    /** Error message */
+    message: string;
+    /** MCP error code (if applicable) */
+    code?: string;
+    /** Unique error tracking ID (from McpError.errorId) */
+    error_id?: string;
+    /** Stack trace (only included when includeStacks is true) */
+    stack?: string;
+}
+/**
+ * Options for StructuredLogTransport.
+ */
+export interface StructuredLogTransportOptions {
+    /** Field names to redact from attributes */
+    redactFields?: string[];
+    /** Whether to include stack traces in error entries (default: true) */
+    includeStacks?: boolean;
+    /** Static fields to include in every log entry */
+    staticFields?: Record<string, unknown>;
+}
+/**
+ * OTel severity numbers mapped from FrontMCP LogLevel.
+ *
+ * @see https://opentelemetry.io/docs/specs/otel/logs/data-model/#severity-fields
+ */
+export declare const LOG_LEVEL_TO_OTEL_SEVERITY: Record<string, number>;

package/otel/context-propagator.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OTel Context Propagator — integrates FrontMCP's W3C trace context
+ * parsing with OpenTelemetry's context propagation.
+ *
+ * This propagator uses the existing FrontMCP trace context parser
+ * to extract and inject W3C traceparent headers.
+ */
+import { type Context, type TextMapGetter, type TextMapSetter, type TextMapPropagator } from '@opentelemetry/api';
+/**
+ * FrontMcpPropagator — OTel TextMapPropagator that reads/writes
+ * the W3C traceparent header using the same format as the SDK.
+ */
+export declare class FrontMcpPropagator implements TextMapPropagator {
+    inject(context: Context, carrier: unknown, setter: TextMapSetter): void;
+    extract(context: Context, carrier: unknown, getter: TextMapGetter): Context;
+    fields(): string[];
+}

package/otel/index.d.ts

@@ -0,0 +1,8 @@
+export { McpAttributes, FrontMcpAttributes, HttpAttributes, RpcAttributes, EnduserAttributes } from './otel.types';
+export type { TracingOptions, OTelSetupOptions } from './otel.types';
+export { OTEL_TRACER, OTEL_CONFIG } from './otel.tokens';
+export { frontmcpToOTelSpanContext, otelToFrontmcpContext, createOTelContextFromTrace } from './trace-context-bridge';
+export type { TraceContextLike } from './trace-context-bridge';
+export { FrontMcpPropagator } from './context-propagator';
+export { setupOTel } from './otel.setup';
+export * from './spans';

package/otel/otel.setup.d.ts

@@ -0,0 +1,32 @@
+/**
+ * setupOTel() — convenience function for configuring the OpenTelemetry SDK.
+ *
+ * This is a thin wrapper around @opentelemetry/sdk-node's NodeSDK.
+ * Users can also configure OTel themselves — the ObservabilityPlugin
+ * only needs @opentelemetry/api to read the global tracer.
+ *
+ * All SDK packages are peer dependencies and lazy-loaded.
+ */
+import type { OTelSetupOptions } from './otel.types';
+/**
+ * Initialize the OpenTelemetry SDK with common defaults.
+ *
+ * This function lazy-loads @opentelemetry/sdk-node and exporter packages
+ * to avoid bundling them unless explicitly called.
+ *
+ * @param options - Setup options (serviceName, exporter, endpoint)
+ * @returns Shutdown function to gracefully stop the SDK
+ *
+ * @example
+ * ```typescript
+ * const shutdown = setupOTel({
+ *   serviceName: 'my-mcp-server',
+ *   exporter: 'otlp',
+ *   endpoint: 'http://localhost:4318',
+ * });
+ *
+ * // On process exit:
+ * await shutdown();
+ * ```
+ */
+export declare function setupOTel(options?: OTelSetupOptions): () => Promise<void>;

package/otel/otel.tokens.d.ts

@@ -0,0 +1,7 @@
+/**
+ * DI tokens for OpenTelemetry providers.
+ */
+/** Token for the OTel Tracer instance */
+export declare const OTEL_TRACER: unique symbol;
+/** Token for the OTel tracing configuration */
+export declare const OTEL_CONFIG: unique symbol;