recoder-analytics/dist/monitoring/error-detector.d.ts

Comprehensive analytics and monitoring for the Recoder.xyz ecosystem

/**
 * Error Pattern Detection & Analysis
 *
 * Intelligent error detection with pattern recognition, categorization,
 * automatic retry logic, and circuit breaker implementation.
 */
import { EventEmitter } from 'events';
export interface ErrorEvent {
    id: string;
    modelName: string;
    provider: string;
    timestamp: Date;
    errorType: ErrorType;
    errorCode?: string;
    message: string;
    requestId?: string;
    userId?: string;
    retryAttempt: number;
    context: {
        inputTokens?: number;
        requestSize?: number;
        region?: string;
        taskType?: string;
        httpStatus?: number;
        responseTime?: number;
        loadLevel?: 'low' | 'medium' | 'high';
    };
    resolved: boolean;
    resolutionTime?: Date;
    resolutionMethod?: 'retry' | 'fallback' | 'manual' | 'timeout';
}
export declare enum ErrorType {
    RATE_LIMIT = "rate_limit",
    API_ERROR = "api_error",
    MODEL_FAILURE = "model_failure",
    NETWORK_ERROR = "network_error",
    AUTHENTICATION = "authentication",
    QUOTA_EXCEEDED = "quota_exceeded",
    TIMEOUT = "timeout",
    VALIDATION_ERROR = "validation_error",
    UNKNOWN = "unknown"
}
export interface ErrorPattern {
    id: string;
    modelName?: string;
    provider?: string;
    errorType: ErrorType;
    pattern: {
        frequency: number;
        timePattern?: string;
        userPattern?: string;
        requestPattern?: string;
    };
    triggers: {
        threshold: number;
        window: number;
        conditions: string[];
    };
    confidence: number;
    firstSeen: Date;
    lastSeen: Date;
    occurrences: number;
    severity: 'low' | 'medium' | 'high' | 'critical';
}
export interface CircuitBreakerState {
    modelName: string;
    state: 'closed' | 'open' | 'half_open';
    failureCount: number;
    lastFailureTime?: Date;
    nextRetryTime?: Date;
    successCount: number;
    config: {
        failureThreshold: number;
        recoveryTimeout: number;
        successThreshold: number;
        monitoringWindow: number;
    };
}
export interface RetryPolicy {
    modelName: string;
    errorType: ErrorType;
    maxRetries: number;
    initialDelayMs: number;
    maxDelayMs: number;
    backoffMultiplier: number;
    jitterMs: number;
    retryConditions: string[];
}
export interface ErrorMetrics {
    modelName: string;
    timeframe: string;
    totalErrors: number;
    errorRate: number;
    rate: number;
    errorsByType: Record<ErrorType, number>;
    mttr: number;
    topErrors: Array<{
        message: string;
        count: number;
        percentage: number;
    }>;
    trend: 'improving' | 'degrading' | 'stable';
    lastUpdated: Date;
}
export interface HistoricalFailurePattern {
    modelName: string;
    riskScore: number;
    patterns: {
        dailyPattern: number[];
        weeklyPattern: number[];
        loadCorrelation: number;
    };
    predictors: Array<{
        factor: string;
        correlation: number;
        significance: number;
    }>;
}
export declare class ErrorDetector extends EventEmitter {
    private errorHistory;
    private errorPatterns;
    private circuitBreakers;
    private retryPolicies;
    private activePatterns;
    private config;
    private patternAnalysisTimer;
    private cleanupTimer;
    private isRunning;
    constructor();
    private initializeErrorTracking;
    private initializeDefaultPolicies;
    /**
     * Start error detection and monitoring
     */
    start(): Promise<void>;
    /**
     * Stop error detection
     */
    stop(): Promise<void>;
    /**
     * Record an error event with enhanced categorization
     */
    recordError(modelName: string, error: {
        errorType?: ErrorType;
        message: string;
        errorCode?: string;
        requestId?: string;
        userId?: string;
        retryAttempt?: number;
        httpStatus?: number;
        responseTime?: number;
        inputTokens?: number;
        context?: any;
    }): Promise<string>;
    /**
     * Mark an error as resolved
     */
    resolveError(errorId: string, resolutionMethod: 'retry' | 'fallback' | 'manual' | 'timeout'): Promise<void>;
    /**
     * Get error metrics for a model
     */
    getErrorMetrics(modelName: string, timeframe?: string): Promise<ErrorMetrics>;
    /**
     * Get error trend analysis
     */
    getErrorTrend(modelName: string, timeframe: string): Promise<{
        isIncreasing: boolean;
        changeRate: number;
        confidence: number;
    }>;
    /**
     * Get historical failure patterns for prediction
     */
    getHistoricalFailurePattern(modelName: string): Promise<HistoricalFailurePattern>;
    /**
     * Check if circuit breaker allows request
     */
    shouldAllowRequest(modelName: string): Promise<boolean>;
    /**
     * Get retry policy for a specific error
     */
    getRetryPolicy(modelName: string, errorType: ErrorType): RetryPolicy | null;
    /**
     * Calculate retry delay with exponential backoff and jitter
     */
    calculateRetryDelay(policy: RetryPolicy, attemptNumber: number): number;
    private getRecentErrors;
    private parseTimeframeMinutes;
    private updateCircuitBreaker;
    private checkForImmediatePatterns;
    private analyzeErrorPatterns;
    private detectPatterns;
    private analyzeErrorTrend;
    private cleanupOldData;
    private getProviderFromModel;
    /**
     * Enhanced error categorization using multiple signals
     */
    private categorizeError;
    /**
     * Get current load level for context
     */
    private getCurrentLoadLevel;
    /**
     * Advanced error pattern detection
     */
    private detectErrorPatterns;
    /**
     * Detect time-based error patterns
     */
    private detectTimeBasedPatterns;
    /**
     * Detect load-based error patterns
     */
    private detectLoadBasedPatterns;
    /**
     * Detect input-based error patterns
     */
    private detectInputBasedPatterns;
    /**
     * Detect user-based error patterns
     */
    private detectUserBasedPatterns;
    /**
     * Advanced error spike analysis
     */
    private analyzeErrorSpike;
    /**
     * Enhanced spike cause identification
     */
    private identifySpikeCause;
}
export declare const errorDetector: ErrorDetector;
//# sourceMappingURL=error-detector.d.ts.map