@spaik/mcp-server-roi/dist/utils/circuit-breaker.d.ts

MCP server for AI ROI prediction and tracking with Monte Carlo simulations

import { EventEmitter } from 'events';
export declare enum CircuitState {
    CLOSED = "CLOSED",// Normal operation
    OPEN = "OPEN",// Failing, rejecting requests
    HALF_OPEN = "HALF_OPEN"
}
export interface CircuitBreakerOptions {
    /**
     * Number of failures before opening the circuit
     */
    failureThreshold?: number;
    /**
     * Time window in ms to count failures
     */
    failureWindow?: number;
    /**
     * Time in ms before attempting to close the circuit
     */
    resetTimeout?: number;
    /**
     * Number of successful calls needed to close from half-open
     */
    successThreshold?: number;
    /**
     * Timeout for individual calls in ms
     */
    timeout?: number;
    /**
     * Name for logging
     */
    name?: string;
    /**
     * Custom error filter to determine if an error should trip the breaker
     */
    errorFilter?: (error: Error) => boolean;
    /**
     * Fallback function when circuit is open
     */
    fallback?: () => Promise<any>;
}
export interface CircuitBreakerStats {
    state: CircuitState;
    failures: number;
    successes: number;
    consecutiveSuccesses: number;
    consecutiveFailures: number;
    lastFailureTime?: Date;
    lastSuccessTime?: Date;
    totalRequests: number;
    rejectedRequests: number;
    timeoutRequests: number;
    fallbackRequests: number;
}
/**
 * Circuit Breaker implementation for fault tolerance
 */
export declare class CircuitBreaker extends EventEmitter {
    private state;
    private failures;
    private successes;
    private consecutiveSuccesses;
    private consecutiveFailures;
    private lastFailureTime?;
    private lastSuccessTime?;
    private totalRequests;
    private rejectedRequests;
    private timeoutRequests;
    private fallbackRequests;
    private resetTimer?;
    private failureTimestamps;
    private readonly options;
    private readonly logger;
    constructor(options?: CircuitBreakerOptions);
    /**
     * Execute a function with circuit breaker protection
     */
    execute<T>(fn: () => Promise<T>, correlationId?: string): Promise<T>;
    /**
     * Handle successful execution
     */
    private onSuccess;
    /**
     * Handle failed execution
     */
    private onFailure;
    /**
     * Open the circuit
     */
    private open;
    /**
     * Move to half-open state
     */
    private halfOpen;
    /**
     * Close the circuit
     */
    private close;
    /**
     * Get current statistics
     */
    getStats(): CircuitBreakerStats;
    /**
     * Reset the circuit breaker
     */
    reset(): void;
    /**
     * Force the circuit to open
     */
    forceOpen(): void;
    /**
     * Force the circuit to close
     */
    forceClose(): void;
    /**
     * Check if circuit is available
     */
    isAvailable(): boolean;
}
/**
 * Factory function to create circuit breakers for different services
 */
export declare function createCircuitBreaker(serviceName: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker;
/**
 * Circuit breaker manager for managing multiple breakers
 */
export declare class CircuitBreakerManager {
    private breakers;
    private logger;
    /**
     * Get or create a circuit breaker for a service
     */
    getBreaker(serviceName: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker;
    /**
     * Get statistics for all breakers
     */
    getAllStats(): Record<string, CircuitBreakerStats>;
    /**
     * Reset all circuit breakers
     */
    resetAll(): void;
    /**
     * Check overall health
     */
    isHealthy(): boolean;
}
export declare const circuitBreakerManager: CircuitBreakerManager;
//# sourceMappingURL=circuit-breaker.d.ts.map