trojanhorse-js/dist/core/CircuitBreaker.d.ts

A comprehensive JavaScript library for fetching, managing, and analyzing global threat intelligence from multiple open-source feeds and security news sources. Unlike its mythological namesake, this Trojan protects your digital fortress.

/// <reference types="node" />
import { EventEmitter } from 'events';
export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
export interface CircuitBreakerConfig {
    failureThreshold: number;
    successThreshold: number;
    timeout: number;
    monitoringWindow: number;
    volumeThreshold: number;
    errorFilter?: (error: Error) => boolean;
    onStateChange?: (state: CircuitState) => void;
}
interface CircuitBreakerStats {
    state: CircuitState;
    failureCount: number;
    successCount: number;
    totalRequests: number;
    lastFailureTime: number | null;
    lastSuccessTime: number | null;
    stateChangeTime: number;
    requestStats: {
        total: number;
        failures: number;
        successes: number;
        timeouts: number;
        circuitOpen: number;
    };
    responseTimeStats: {
        average: number;
        min: number;
        max: number;
        p95: number;
        p99: number;
    };
}
export declare class CircuitBreaker extends EventEmitter {
    private config;
    private state;
    private failureCount;
    private successCount;
    private lastFailureTime;
    private lastSuccessTime;
    private stateChangeTime;
    private requestHistory;
    private responseTimes;
    constructor(config?: Partial<CircuitBreakerConfig>);
    execute<T>(fn: () => Promise<T>): Promise<T>;
    executeWithRetry<T>(fn: () => Promise<T>, maxRetries?: number, retryDelay?: number): Promise<T>;
    executeBatch<T>(functions: Array<() => Promise<T>>, options?: {
        maxConcurrency?: number;
        failFast?: boolean;
        continueOnFailure?: boolean;
    }): Promise<Array<{
        success: boolean;
        result?: T;
        error?: Error;
    }>>;
    private onSuccess;
    private onFailure;
    private shouldOpen;
    private shouldAttemptReset;
    private setState;
    private reset;
    private recordRequest;
    private getRecentRequests;
    private cleanupOldRecords;
    private calculatePercentile;
    private sleep;
    getStats(): CircuitBreakerStats;
    getState(): CircuitState;
    getConfig(): CircuitBreakerConfig;
    updateConfig(newConfig: Partial<CircuitBreakerConfig>): void;
    open(): void;
    close(): void;
    halfOpen(): void;
    isHealthy(): boolean;
    getHealthScore(): number;
    exportMetrics(): Record<string, number>;
}
export declare class CircuitBreakerManager {
    private breakers;
    private globalConfig;
    constructor(globalConfig?: Partial<CircuitBreakerConfig>);
    getBreaker(serviceName: string, config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
    execute<T>(serviceName: string, fn: () => Promise<T>, config?: Partial<CircuitBreakerConfig>): Promise<T>;
    getAllStats(): Record<string, CircuitBreakerStats>;
    getSystemHealth(): {
        healthy: number;
        degraded: number;
        unhealthy: number;
        totalServices: number;
        overallScore: number;
    };
    resetAll(): void;
    removeBreaker(serviceName: string): boolean;
}
export declare function createCircuitBreaker(pattern: 'aggressive' | 'conservative' | 'api' | 'database' | 'custom', customConfig?: Partial<CircuitBreakerConfig>): CircuitBreaker;
export {};
//# sourceMappingURL=CircuitBreaker.d.ts.map