polyv-live-cli/dist/performance/fallback-manager.d.ts

CLI tool for managing PolyV live streaming services.

import { EventEmitter } from 'events';
export interface FallbackManagerConfig {
    enableAutoFallback: boolean;
    maxRetryAttempts: number;
    retryDelay: number;
    retryDelayMultiplier: number;
    maxRetryDelay: number;
    circuitBreakerThreshold: number;
    circuitBreakerTimeout: number;
    healthCheckInterval: number;
    requestTimeout: number;
    enableFallbackCache: boolean;
    fallbackCacheTtl: number;
}
export type ServiceHealthStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
export type CircuitBreakerState = 'closed' | 'open' | 'half-open';
export type FallbackStrategy = 'cache' | 'alternative-endpoint' | 'mock-data' | 'partial-response' | 'offline-mode';
export interface ServiceEndpoint {
    id: string;
    url: string;
    priority: number;
    isPrimary: boolean;
    healthStatus: ServiceHealthStatus;
    lastHealthCheck: number;
    responseTime: number;
    successRate: number;
    circuitBreakerState: CircuitBreakerState;
    consecutiveFailures: number;
}
export interface FallbackRule {
    id: string;
    serviceId: string;
    triggers: FallbackTrigger[];
    strategy: FallbackStrategy;
    config: Record<string, any>;
    priority: number;
    enabled: boolean;
}
export interface FallbackTrigger {
    type: 'error-rate' | 'response-time' | 'status-code' | 'timeout' | 'circuit-breaker';
    threshold: number;
    timeWindow: number;
    minSamples: number;
}
export interface FallbackResult {
    success: boolean;
    strategy: FallbackStrategy;
    data: any;
    responseTime: number;
    error?: Error;
    source: 'primary' | 'fallback' | 'cache' | 'mock';
}
export interface ServiceHealthMetrics {
    serviceId: string;
    healthStatus: ServiceHealthStatus;
    endpoints: ServiceEndpoint[];
    successRate: number;
    averageResponseTime: number;
    errorRate: number;
    lastSuccessful: number;
    totalRequests: number;
    failedRequests: number;
    circuitBreakerStatus: Record<string, CircuitBreakerState>;
}
export interface FallbackStats {
    totalFallbacks: number;
    fallbacksByStrategy: Record<FallbackStrategy, number>;
    fallbackSuccessRate: number;
    serviceHealth: Map<string, ServiceHealthMetrics>;
    activeRules: number;
    circuitBreakerActivations: number;
    cacheHitRate: number;
}
export declare class FallbackManager extends EventEmitter {
    private config;
    private services;
    private fallbackRules;
    private fallbackCache;
    private healthCheckTimer?;
    private stats;
    private isRunning;
    private requestHistory;
    constructor(config?: Partial<FallbackManagerConfig>);
    start(): void;
    stop(): void;
    registerService(serviceId: string, endpoints: Omit<ServiceEndpoint, 'healthStatus' | 'lastHealthCheck' | 'responseTime' | 'successRate' | 'circuitBreakerState' | 'consecutiveFailures'>[]): void;
    addFallbackRule(rule: FallbackRule): void;
    removeFallbackRule(serviceId: string, ruleId: string): void;
    executeWithFallback(serviceId: string, requestFn: (endpoint: ServiceEndpoint) => Promise<any>, options?: {
        cacheKey?: string;
        enableCache?: boolean;
        mockData?: any;
        timeout?: number;
    }): Promise<FallbackResult>;
    getServiceHealth(serviceId: string): ServiceHealthMetrics | null;
    getStats(): FallbackStats;
    openCircuitBreaker(serviceId: string, endpointId: string): void;
    closeCircuitBreaker(serviceId: string, endpointId: string): void;
    updateConfig(newConfig: Partial<FallbackManagerConfig>): void;
    clearCache(): void;
    private getPrimaryEndpoint;
    private canUseEndpoint;
    private executeRequest;
    private executeFallback;
    private getApplicableFallbackRules;
    private isRuleTriggered;
    private executeFallbackStrategy;
    private executeCacheFallback;
    private executeAlternativeEndpointFallback;
    private executeMockDataFallback;
    private executePartialResponseFallback;
    private executeOfflineModeFallback;
    private getCachedResult;
    private cacheResult;
    private recordSuccess;
    private recordFailure;
    private updateServiceHealthMetrics;
    private startHealthChecks;
    private performHealthChecks;
    private setupEventHandlers;
    private cleanupExpiredCache;
}
//# sourceMappingURL=fallback-manager.d.ts.map