recoder-analytics/dist/monitoring/latency-monitor.d.ts

Comprehensive analytics and monitoring for the Recoder.xyz ecosystem

/**
 * Latency Monitoring & Optimization with Percentile Tracking
 *
 * Comprehensive latency tracking with percentile calculations, spike detection,
 * trend analysis, and performance optimization recommendations.
 */
import { EventEmitter } from 'events';
export interface LatencyMetrics {
    p50: number;
    p95: number;
    p99: number;
    avg: number;
    min: number;
    max: number;
    trend: 'improving' | 'degrading' | 'stable';
    sampleCount: number;
    timeframe: string;
    timestamp: Date;
}
export interface LatencyEvent {
    modelName: string;
    provider: string;
    latency: number;
    timestamp: Date;
    requestId?: string;
    taskType?: string;
    tokenCount?: number;
    region?: string;
    success: boolean;
}
export interface LatencySpike {
    modelName: string;
    startTime: Date;
    endTime?: Date;
    peakLatency: number;
    averageLatency: number;
    affectedRequests: number;
    severity: 'minor' | 'moderate' | 'severe' | 'critical';
    possibleCause?: string;
    resolved: boolean;
}
export interface LatencyTrend {
    modelName: string;
    timeframe: string;
    isIncreasing: boolean;
    changeRate: number;
    confidence: number;
    dataPoints: number;
    predictedLatency?: number;
}
export interface PerformanceBenchmark {
    modelName: string;
    taskType: string;
    expectedLatency: {
        p50: number;
        p95: number;
        p99: number;
    };
    tolerance: number;
    lastUpdated: Date;
}
export interface OptimizationRecommendation {
    modelName: string;
    type: 'model_switch' | 'request_optimization' | 'regional_routing' | 'load_balancing';
    description: string;
    expectedImprovement: number;
    confidence: number;
    implementation: string;
}
export declare class LatencyMonitor extends EventEmitter {
    private latencyData;
    private activeSpikes;
    private spikeHistory;
    private benchmarks;
    private config;
    private cleanupTimer;
    private isRunning;
    constructor();
    private initializeModels;
    /**
     * Start latency monitoring
     */
    start(): Promise<void>;
    /**
     * Stop latency monitoring
     */
    stop(): Promise<void>;
    /**
     * Track a request's latency
     */
    trackRequest(modelName: string, startTime: number, endTime: number, options?: {
        requestId?: string;
        taskType?: string;
        tokenCount?: number;
        region?: string;
        success?: boolean;
    }): Promise<void>;
    /**
     * Get latency metrics for a model over a time range
     */
    getLatencyMetrics(modelName: string, timeRange?: string): Promise<LatencyMetrics>;
    /**
     * Detect latency spikes above threshold
     */
    detectLatencySpikes(threshold?: number): Promise<LatencySpike[]>;
    /**
     * Analyze latency trends for a model
     */
    getLatencyTrend(modelName: string, timeRange?: string): Promise<LatencyTrend>;
    /**
     * Get models optimized for latency
     */
    optimizeForLatency(): Promise<string[]>;
    /**
     * Get optimization recommendations for a model
     */
    getOptimizationRecommendations(modelName: string): Promise<OptimizationRecommendation[]>;
    /**
     * Set performance benchmarks for a model
     */
    setBenchmark(modelName: string, taskType: string, expectedLatency: {
        p50: number;
        p95: number;
        p99: number;
    }, tolerance?: number): Promise<void>;
    /**
     * Check if current performance meets benchmarks
     */
    checkBenchmarkCompliance(modelName: string, taskType?: string): Promise<{
        compliant: boolean;
        violations: Array<{
            taskType: string;
            metric: string;
            expected: number;
            actual: number;
            deviation: number;
        }>;
    }>;
    private getRecentEvents;
    private getTimeRangeCutoff;
    private parseTimeRange;
    private calculatePercentile;
    private analyzeTrend;
    private calculateLinearRegression;
    private predictLatency;
    private checkForSpikes;
    private calculateSpikeSeverity;
    private identifySpikeCause;
    private getRegionalLatencyData;
    private cleanupOldData;
    private getProviderFromModel;
}
export declare const latencyMonitor: LatencyMonitor;
//# sourceMappingURL=latency-monitor.d.ts.map