mcp-server-framework 1.0.0

package/build/logger/core/trace-context.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Trace Context Extraction — Plugin Interface
+ *
+ * Provides a decoupled mechanism for enriching log entries with trace context
+ * (traceId, spanId) without the logger module depending on any tracing library.
+ *
+ * The logger defines the interface; the telemetry layer injects the implementation
+ * at startup via {@link setTraceContextExtractor}. Before injection, all calls
+ * to {@link extractTraceContext} return `undefined` — safe because no spans
+ * can exist before the tracing SDK starts.
+ *
+ * @module logger/core/trace-context
+ */
+/** Trace context data returned by the extractor. */
+export interface TraceContext {
+    readonly traceId: string;
+    readonly spanId: string;
+}
+/**
+ * Plugin interface for trace context extraction.
+ *
+ * Implementations extract the current trace/span IDs from the active
+ * tracing context (e.g., OpenTelemetry's active span). The logger calls
+ * {@link TraceContextExtractor.extract} on every log entry to enrich
+ * structured logs with correlation IDs.
+ */
+export interface TraceContextExtractor {
+    /** Extract the current trace context, or `undefined` if no active span. */
+    extract(): TraceContext | undefined;
+}
+/**
+ * Register a trace context extractor implementation.
+ *
+ * Called by the telemetry layer after SDK initialization to inject
+ * an OTEL-based (or custom) extractor. Replaces any previously
+ * registered extractor.
+ *
+ * @param impl - The extractor implementation to register
+ */
+export declare function setTraceContextExtractor(impl: TraceContextExtractor): void;
+/**
+ * Extract the current trace context (traceId, spanId).
+ *
+ * Returns `undefined` when no extractor has been registered yet
+ * (i.e., before the telemetry SDK starts). After registration,
+ * delegates to the injected extractor.
+ *
+ * @returns Trace context with traceId and spanId, or `undefined`
+ */
+export declare function extractTraceContext(): TraceContext | undefined;
+//# sourceMappingURL=trace-context.d.ts.map

package/build/logger/core/trace-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-context.d.ts","sourceRoot":"","sources":["../../../src/logger/core/trace-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC,2EAA2E;IAC3E,OAAO,IAAI,YAAY,GAAG,SAAS,CAAC;CACrC;AAQD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAE1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,GAAG,SAAS,CAE9D"}

package/build/logger/core/trace-context.js

@@ -0,0 +1,42 @@
+/**
+ * Trace Context Extraction — Plugin Interface
+ *
+ * Provides a decoupled mechanism for enriching log entries with trace context
+ * (traceId, spanId) without the logger module depending on any tracing library.
+ *
+ * The logger defines the interface; the telemetry layer injects the implementation
+ * at startup via {@link setTraceContextExtractor}. Before injection, all calls
+ * to {@link extractTraceContext} return `undefined` — safe because no spans
+ * can exist before the tracing SDK starts.
+ *
+ * @module logger/core/trace-context
+ */
+// ============================================================================
+// Singleton Slot
+// ============================================================================
+let extractor = null;
+/**
+ * Register a trace context extractor implementation.
+ *
+ * Called by the telemetry layer after SDK initialization to inject
+ * an OTEL-based (or custom) extractor. Replaces any previously
+ * registered extractor.
+ *
+ * @param impl - The extractor implementation to register
+ */
+export function setTraceContextExtractor(impl) {
+    extractor = impl;
+}
+/**
+ * Extract the current trace context (traceId, spanId).
+ *
+ * Returns `undefined` when no extractor has been registered yet
+ * (i.e., before the telemetry SDK starts). After registration,
+ * delegates to the injected extractor.
+ *
+ * @returns Trace context with traceId and spanId, or `undefined`
+ */
+export function extractTraceContext() {
+    return extractor?.extract();
+}
+//# sourceMappingURL=trace-context.js.map

package/build/logger/core/trace-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-context.js","sourceRoot":"","sources":["../../../src/logger/core/trace-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAyBH,+EAA+E;AAC/E,iBAAiB;AACjB,+EAA+E;AAE/E,IAAI,SAAS,GAAiC,IAAI,CAAC;AAEnD;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAA2B;IAClE,SAAS,GAAG,IAAI,CAAC;AACnB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO,SAAS,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC"}

package/build/logger/core/types.d.ts

@@ -0,0 +1,233 @@
+/**
+ * Logger Core Types Module
+ *
+ * Defines the fundamental types and interfaces for the logging system.
+ * These types are used throughout all logger components.
+ *
+ * @module logger/core/types
+ */
+/**
+ * Transport modes for logger output routing.
+ *
+ * Defined locally to decouple the logger from server-layer types.
+ * The logger only needs this to decide stderr vs stdout routing.
+ *
+ * - `stdio` — ALL logs to stderr (stdout reserved for JSON-RPC)
+ * - `http` / `https` — Standard stream routing
+ */
+export type TransportMode = "stdio" | "http" | "https";
+/**
+ * Available logging levels ordered by severity (lowest to highest).
+ *
+ * - `trace`: Very detailed debugging information
+ * - `debug`: Detailed debugging information
+ * - `info`: General informational messages
+ * - `warn`: Warning conditions
+ * - `error`: Error conditions
+ */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error";
+/**
+ * MCP Logging levels as defined by the MCP specification (RFC 5424).
+ *
+ * MCP uses syslog-style levels which are more granular than our internal levels.
+ */
+export type McpLogLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+/**
+ * HTTP request context for structured logging.
+ * Used to correlate logs with specific HTTP requests.
+ */
+export interface HttpContext {
+    /** HTTP method (GET, POST, etc.) */
+    method?: string;
+    /** Request URL path */
+    path?: string;
+    /** Response status code */
+    statusCode?: number;
+    /** Request duration in milliseconds */
+    durationMs?: number;
+}
+/**
+ * Event context for structured logging.
+ * Used to categorize and track log events.
+ */
+export interface EventContext {
+    /** Event category (e.g., 'tool', 'api', 'transport') */
+    category?: string;
+    /** Event action (e.g., 'execute', 'connect', 'disconnect') */
+    action?: string;
+    /** Event outcome */
+    outcome?: "success" | "failure" | "unknown";
+}
+/**
+ * Context for the current execution (e.g. Request ID, MCP Connection).
+ * Used to correlate logs with specific requests or sessions.
+ */
+export interface LogContext {
+    /** Unique identifier for the request */
+    requestId?: string;
+    /** Session identifier */
+    sessionId?: string;
+    /** Component name for filtering */
+    component?: string;
+    /** Trace ID for distributed tracing (OpenTelemetry compatible) */
+    traceId?: string;
+    /** Span ID for distributed tracing */
+    spanId?: string;
+    /** HTTP request context */
+    http?: HttpContext;
+    /** Event categorization for structured logs */
+    event?: EventContext;
+    /** Function to send logs to MCP client */
+    sendMcpLog?: (level: LogLevel, message: string) => void;
+    /**
+     * Internal depth counter for context nesting.
+     * Used to prevent infinite recursion - thread-safe as it's per-context.
+     * @internal
+     */
+    _depth?: number;
+}
+/**
+ * Interface for a logger instance.
+ * Defines the public API that all logger implementations must follow.
+ */
+export interface LoggerInterface {
+    /**
+     * Log a message at TRACE level.
+     * @param message - The message to log (supports printf-style formatting)
+     * @param args - Additional arguments for formatting or metadata
+     */
+    trace(message: string, ...args: unknown[]): void;
+    /**
+     * Log a message at DEBUG level.
+     * @param message - The message to log (supports printf-style formatting)
+     * @param args - Additional arguments for formatting or metadata
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Log a message at INFO level.
+     * @param message - The message to log (supports printf-style formatting)
+     * @param args - Additional arguments for formatting or metadata
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Log a message at WARN level.
+     * @param message - The message to log (supports printf-style formatting)
+     * @param args - Additional arguments for formatting or metadata
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Log a message at ERROR level.
+     * @param message - The message to log (supports printf-style formatting)
+     * @param args - Additional arguments for formatting or metadata
+     */
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Create a child logger with a specific component context.
+     * @param context - The component context for the child logger
+     * @returns A new logger instance with the specified context
+     */
+    child(context: {
+        component: string;
+    }): LoggerInterface;
+    /**
+     * Run a function within a logging context.
+     * @param context - The context to use for logging
+     * @param fn - The function to execute
+     * @returns The result of the function
+     */
+    runWithContext<T>(context: LogContext, fn: () => T): T;
+    /**
+     * Get the current logging context.
+     * @returns The current context or undefined if not in a context
+     */
+    getContext(): LogContext | undefined;
+}
+/**
+ * Interface for log writers.
+ * Writers are responsible for outputting formatted log entries to specific destinations.
+ */
+export interface LogWriter {
+    /**
+     * Write a log entry to the destination.
+     * @param level - The log level
+     * @param message - The formatted log message
+     * @param component - The component that generated the log
+     */
+    write(level: LogLevel, message: string, component: string): void;
+    /**
+     * Close the writer and release any resources.
+     * @returns Promise that resolves when the writer is closed
+     */
+    close(): Promise<void>;
+    /**
+     * Check if the writer is available/ready.
+     * @returns true if the writer can accept log entries
+     */
+    isAvailable(): boolean;
+}
+/**
+ * Interface for log formatters.
+ * Formatters are responsible for converting log data into formatted strings.
+ */
+export interface LogFormatter {
+    /**
+     * Format a log entry.
+     * @param params - The log entry parameters
+     * @returns The formatted log string
+     */
+    format(params: LogEntryParams): string;
+}
+/**
+ * Parameters for formatting a log entry.
+ */
+export interface LogEntryParams {
+    /** Log level */
+    level: LogLevel;
+    /** Log message (may contain printf-style placeholders) */
+    message: string;
+    /** Format arguments for printf-style placeholders */
+    formatArgs?: unknown[];
+    /** Component name */
+    component: string;
+    /** Optional logging context */
+    context?: LogContext;
+    /** Optional metadata object */
+    metadata?: Record<string, unknown>;
+    /** Optional error (auto-detected from args or explicitly set) */
+    error?: Error;
+    /** Timestamp (ISO 8601) */
+    timestamp?: string;
+}
+/**
+ * Configuration for creating a logger instance.
+ */
+export interface LoggerConfig {
+    /** Minimum log level to output */
+    level: LogLevel;
+    /** Log format ('json' or 'text') */
+    format: "json" | "text";
+    /** Service name for structured logs */
+    serviceName: string;
+    /** Service version */
+    serviceVersion: string;
+    /** Environment (e.g., 'development', 'production') */
+    environment: string;
+    /** Transport mode (determines console output routing) */
+    transport: TransportMode;
+    /** Directory for file logging (optional) */
+    logDir?: string;
+}
+/**
+ * Interface for sending log notifications to external consumers.
+ *
+ * Implementations deliver log messages to connected clients (e.g., MCP
+ * clients via notifications/message). The logger uses this interface
+ * instead of depending directly on the MCP SDK.
+ *
+ * Implementations are registered via {@link McpNotificationLogger.addHandler}.
+ */
+export interface LogNotificationHandler {
+    /** Send a log notification at the given MCP log level. */
+    sendLogNotification(level: McpLogLevel, message: string): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/logger/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/logger/core/types.ts"],"names":[],"mappings":"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"}

package/build/logger/core/types.js

@@ -0,0 +1,10 @@
+/**
+ * Logger Core Types Module
+ *
+ * Defines the fundamental types and interfaces for the logging system.
+ * These types are used throughout all logger components.
+ *
+ * @module logger/core/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/build/logger/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/logger/core/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/build/logger/factory.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Logger Factory Module
+ *
+ * Provides dependency injection and testable configuration for the logging system.
+ * Eliminates static state anti-pattern while maintaining backward compatibility.
+ *
+ * @module logger/factory
+ */
+import type { LogLevel, TransportMode, LogFormatter, LogWriter } from "./core/types.js";
+import { SecretScrubber } from "./scrubbing/secret-scrubber.js";
+import { InjectionGuard } from "./scrubbing/injection-guard.js";
+/**
+ * Complete configuration for the logging system.
+ */
+export interface LoggerSystemConfig {
+    /** Minimum log level */
+    level: LogLevel;
+    /** Output format (text or json) */
+    format: "text" | "json";
+    /** Transport mode (affects console output) */
+    transport: TransportMode;
+    /** Service name for structured logs */
+    serviceName: string;
+    /** Service version for structured logs */
+    serviceVersion: string;
+    /** Environment name */
+    environment: string;
+    /** Directory for file logging (optional) */
+    logDir?: string;
+    /** Maximum size of child logger cache */
+    maxChildLoggerCacheSize?: number;
+    /** Maximum log file size in bytes before rotation */
+    maxFileSize?: number;
+    /** Number of rotated log files to keep */
+    maxFiles?: number;
+    /** Log file retention in days (0 = disabled) */
+    retentionDays?: number;
+    /** Include RFC 3339 timestamps in text log output (default: true) */
+    includeTimestamp?: boolean;
+    /** Include component name in text log output (default: true) */
+    includeComponent?: boolean;
+    /** Hostname (computed once at init via os.hostname()) */
+    hostname?: string;
+    /** CPU architecture (default: process.arch) */
+    architecture?: string;
+    /** OS type / platform (default: process.platform) */
+    osType?: string;
+    /** Process ID (default: process.pid) */
+    pid?: number;
+    /** Process name (default: 'node') */
+    processName?: string;
+}
+/**
+ * Dependencies that can be injected for testing.
+ */
+export interface LoggerDependencies {
+    textFormatter?: LogFormatter;
+    jsonFormatter?: LogFormatter;
+    consoleWriter?: LogWriter;
+    fileWriter?: LogWriter;
+    secretScrubber?: SecretScrubber;
+    injectionGuard?: InjectionGuard;
+}
+/**
+ * Container for logger resources.
+ * Encapsulates all shared resources that were previously static.
+ */
+export declare class LoggerResources {
+    readonly textFormatter: LogFormatter;
+    readonly jsonFormatter: LogFormatter | null;
+    readonly consoleWriter: LogWriter | null;
+    readonly fileWriter: LogWriter | null;
+    readonly secretScrubber: SecretScrubber;
+    readonly injectionGuard: InjectionGuard;
+    readonly format: "text" | "json";
+    readonly maxChildLoggerCacheSize: number;
+    /** Child logger cache with LRU eviction */
+    private readonly childLoggerCache;
+    private readonly childLoggerOrder;
+    constructor(config: LoggerSystemConfig, deps?: LoggerDependencies);
+    /**
+     * Create file writer with error handling.
+     */
+    private createFileWriter;
+    /**
+     * Get the appropriate formatter based on configuration.
+     */
+    getFormatter(): LogFormatter;
+    /**
+     * Get or create a cached child logger.
+     * Uses LRU eviction to prevent memory leaks.
+     */
+    getOrCreateChildLogger<T>(key: string, factory: () => T): T;
+    /**
+     * Clear the child logger cache.
+     */
+    clearChildLoggerCache(): void;
+    /**
+     * Get the current cache size.
+     */
+    getChildLoggerCacheSize(): number;
+    /**
+     * Get child logger cache statistics for monitoring.
+     * @internal
+     */
+    getChildLoggerCacheStats(): {
+        size: number;
+        maxSize: number;
+    };
+    /**
+     * Close all writers gracefully.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Initialize global logger resources.
+ * Called once with the application configuration.
+ *
+ * @param config - Logger system configuration
+ * @param deps - Optional dependencies for testing
+ * @returns The initialized resources
+ */
+export declare function initializeLoggerResources(config: LoggerSystemConfig, deps?: LoggerDependencies): LoggerResources;
+/**
+ * Get the global logger resources.
+ * Throws if not initialized.
+ *
+ * @returns The global resources
+ * @throws Error if resources not initialized
+ */
+export declare function getLoggerResources(): LoggerResources;
+/**
+ * Check if global resources are initialized.
+ */
+export declare function hasLoggerResources(): boolean;
+/**
+ * Reset global resources (for testing).
+ * Closes existing resources before resetting.
+ *
+ * @internal
+ */
+export declare function resetLoggerResources(): Promise<void>;
+/**
+ * Force set global resources (for testing only).
+ * Bypasses initialization check.
+ *
+ * @internal
+ */
+export declare function _setLoggerResources(resources: LoggerResources | null): void;
+//# sourceMappingURL=factory.d.ts.map

package/build/logger/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/logger/factory.ts"],"names":[],"mappings":"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"}