lightweight-browser-load-tester/dist/managers/error-recovery.d.ts

A lightweight load testing tool using real browsers for streaming applications with DRM support

import { EventEmitter } from 'events';
/**
 * Circuit breaker states
 */
export declare enum CircuitBreakerState {
    CLOSED = "closed",// Normal operation
    OPEN = "open",// Failing, rejecting requests
    HALF_OPEN = "half-open"
}
/**
 * Circuit breaker configuration
 */
export interface CircuitBreakerConfig {
    failureThreshold: number;
    recoveryTimeout: number;
    successThreshold: number;
    monitoringWindow: number;
}
/**
 * Browser instance failure tracking
 */
export interface InstanceFailureInfo {
    instanceId: string;
    failureCount: number;
    lastFailureTime: Date;
    consecutiveFailures: number;
    totalRestarts: number;
    isBlacklisted: boolean;
    blacklistUntil?: Date;
}
/**
 * Recovery attempt result
 */
export interface RecoveryAttempt {
    instanceId: string;
    timestamp: Date;
    success: boolean;
    error?: Error;
    attemptNumber: number;
}
/**
 * Error recovery manager that handles browser instance failures and recovery
 */
export declare class ErrorRecoveryManager extends EventEmitter {
    private circuitBreakers;
    private failureTracking;
    private recoveryAttempts;
    private config;
    private cleanupInterval?;
    constructor(config?: Partial<CircuitBreakerConfig>);
    /**
     * Record a failure for a browser instance
     */
    recordFailure(instanceId: string, error: Error, context?: Record<string, any>): void;
    /**
     * Record a successful operation for a browser instance
     */
    recordSuccess(instanceId: string): void;
    /**
     * Check if an instance should be allowed to operate
     */
    canUseInstance(instanceId: string): boolean;
    /**
     * Determine if an instance should be restarted
     */
    shouldRestartInstance(instanceId: string): boolean;
    /**
     * Record a restart attempt
     */
    recordRestartAttempt(instanceId: string, success: boolean, error?: Error): void;
    /**
     * Get failure statistics for an instance
     */
    getInstanceStats(instanceId: string): InstanceFailureInfo | null;
    /**
     * Get circuit breaker state for an instance
     */
    getCircuitBreakerState(instanceId: string): CircuitBreakerState;
    /**
     * Get all recovery attempts for an instance
     */
    getRecoveryAttempts(instanceId: string): RecoveryAttempt[];
    /**
     * Get comprehensive error recovery statistics
     */
    getRecoveryStats(): {
        totalInstances: number;
        failingInstances: number;
        blacklistedInstances: number;
        openCircuitBreakers: number;
        halfOpenCircuitBreakers: number;
        totalFailures: number;
        totalRestarts: number;
    };
    /**
     * Reset failure tracking for an instance
     */
    resetInstance(instanceId: string): void;
    /**
     * Cleanup old tracking data
     */
    cleanup(): void;
    /**
     * Shutdown the error recovery manager
     */
    shutdown(): void;
    /**
     * Evaluate circuit breaker state based on failure info
     */
    private evaluateCircuitBreaker;
    /**
     * Blacklist an instance temporarily
     */
    private blacklistInstance;
    /**
     * Start periodic cleanup process
     */
    private startCleanupProcess;
    /**
     * Log error with comprehensive context
     */
    private logError;
}
//# sourceMappingURL=error-recovery.d.ts.map