polyv-live-cli/dist/performance/error-recovery-manager.d.ts

CLI tool for managing PolyV live streaming services.

import { EventEmitter } from 'events';
export interface ErrorRecoveryConfig {
    enableAutoRecovery: boolean;
    maxRetryAttempts: number;
    baseRetryDelay: number;
    retryDelayMultiplier: number;
    maxRetryDelay: number;
    errorHistorySize: number;
    criticalErrorThreshold: number;
    recoveryTimeout: number;
    enableErrorLogging: boolean;
    enableUserNotifications: boolean;
    fallbackModeTimeout: number;
}
export type ErrorType = 'network' | 'api' | 'render' | 'memory' | 'configuration' | 'validation' | 'timeout' | 'permission' | 'unknown';
export type ErrorSeverity = 'low' | 'medium' | 'high' | 'critical';
export type RecoveryStrategy = 'retry' | 'fallback' | 'reset' | 'ignore' | 'escalate' | 'restart';
export interface ErrorRecord {
    id: string;
    type: ErrorType;
    severity: ErrorSeverity;
    message: string;
    stack?: string;
    context: {
        component: string;
        operation: string;
        parameters?: Record<string, any>;
        timestamp: number;
    };
    recoveryAttempts: number;
    maxRetries: number;
    recovered: boolean;
    recoveryStrategy?: RecoveryStrategy;
    recoveryTime?: number;
    firstOccurrence: number;
    lastOccurrence: number;
    occurrenceCount: number;
}
export interface ErrorPattern {
    id: string;
    description: string;
    errorType: ErrorType;
    componentPattern: string;
    messagePattern: RegExp;
    recoveryStrategy: RecoveryStrategy;
    confidence: number;
    occurrences: number;
    lastSeen: number;
}
export interface RecoveryResult {
    success: boolean;
    strategy: RecoveryStrategy;
    recoveryTime: number;
    error: ErrorRecord;
    details?: string;
    newError?: Error;
}
export interface ErrorStatistics {
    totalErrors: number;
    errorsByType: Record<ErrorType, number>;
    errorsBySeverity: Record<ErrorSeverity, number>;
    errorsByComponent: Record<string, number>;
    recoverySuccessRate: number;
    averageRecoveryTime: number;
    commonPatterns: ErrorPattern[];
    trends: {
        errorRate: number;
        recoveryRate: number;
        criticalErrors: number;
        recentErrors: number;
    };
}
export interface UserErrorMessage {
    id: string;
    title: string;
    description: string;
    suggestedActions: string[];
    severity: 'info' | 'warning' | 'error';
    recoverable: boolean;
    recoveryStatus: 'pending' | 'in-progress' | 'completed' | 'failed';
}
export declare class ErrorRecoveryManager extends EventEmitter {
    private config;
    private errorHistory;
    private errorPatterns;
    private recoveryStrategies;
    private errorIdCounter;
    private patternIdCounter;
    private isRunning;
    private criticalErrorCount;
    private fallbackModeActive;
    private fallbackModeTimer?;
    constructor(config?: Partial<ErrorRecoveryConfig>);
    start(): void;
    stop(): void;
    reportError(error: Error, context: {
        component: string;
        operation: string;
        parameters?: Record<string, any>;
    }): Promise<void>;
    attemptRecovery(errorRecord: ErrorRecord): Promise<RecoveryResult>;
    getStatistics(): ErrorStatistics;
    getErrorHistory(timeRange?: {
        start: number;
        end: number;
    }): ErrorRecord[];
    getUserErrorMessage(errorRecord: ErrorRecord): UserErrorMessage;
    clearErrorHistory(): void;
    updateConfig(newConfig: Partial<ErrorRecoveryConfig>): void;
    registerRecoveryStrategy(name: string, strategy: (error: ErrorRecord) => Promise<RecoveryResult>): void;
    activateFallbackMode(): void;
    deactivateFallbackMode(): void;
    isFallbackModeActive(): boolean;
    private createErrorRecord;
    private classifyError;
    private determineSeverity;
    private getMaxRetries;
    private findExistingError;
    private learnErrorPattern;
    private updateErrorPattern;
    private determineRecoveryStrategy;
    private initializeRecoveryStrategies;
    private initializeErrorPatterns;
    private createTimeoutPromise;
    private logError;
    private mapSeverityToUser;
    private isErrorRecoverable;
    private getRecoveryStatus;
    private generateUserFriendlyTitle;
    private generateUserFriendlyDescription;
    private generateUserActions;
    private setupEventHandlers;
}
//# sourceMappingURL=error-recovery-manager.d.ts.map