agentic-qe/dist/agents/ProductionIntelligenceAgent.d.ts

Agentic Quality Engineering Fleet System - AI-driven quality management platform

/**
 * ProductionIntelligenceAgent - Converts production data into test scenarios
 *
 * Implements incident replay testing, RUM analysis, anomaly detection,
 * load pattern analysis, and feature usage analytics to close the
 * production-to-testing feedback loop.
 *
 * Based on SPARC methodology and AQE Fleet specification
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { QETask } from '../types';
export interface ProductionIntelligenceConfig extends BaseAgentConfig {
    monitoringPlatforms?: {
        datadog?: {
            apiKey: string;
            appKey: string;
            site?: string;
        };
        newRelic?: {
            apiKey: string;
            accountId: string;
        };
        grafana?: {
            url: string;
            apiKey: string;
        };
    };
    thresholds?: {
        anomalyStdDev: number;
        errorRateSpike: number;
        latencyDegradation: number;
        minIncidentOccurrences: number;
    };
    features?: {
        incidentReplay: boolean;
        rumAnalysis: boolean;
        anomalyDetection: boolean;
        loadPatternAnalysis: boolean;
        featureUsageAnalytics: boolean;
    };
}
export interface ProductionIncident {
    id: string;
    timestamp: string;
    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    service: string;
    error: string;
    affectedUsers: number;
    duration: number;
    region: string;
    context: {
        systemState: {
            cpu: number;
            memory: number;
            connections: number;
            queueDepth: number;
            cacheHitRate: number;
        };
        requestTrace?: {
            traceId: string;
            spanId: string;
            duration: number;
            hops: Array<{
                service: string;
                duration: number;
                timeout?: boolean;
            }>;
        };
        userContext?: {
            userId: string;
            sessionId: string;
            userAgent: string;
            location: string;
        };
        environmentalFactors?: {
            trafficSpike?: boolean;
            deploymentRecent?: boolean;
            externalServiceDegraded?: string;
            databaseSlowQuery?: boolean;
        };
    };
}
export interface RUMData {
    timeWindow: string;
    totalSessions: number;
    totalPageViews: number;
    userJourneys: UserJourney[];
    deviceDistribution: Record<string, number>;
    browserDistribution: Record<string, number>;
    performanceMetrics: {
        FCP: {
            p50: number;
            p95: number;
            p99: number;
        };
        LCP: {
            p50: number;
            p95: number;
            p99: number;
        };
        FID: {
            p50: number;
            p95: number;
            p99: number;
        };
        CLS: {
            p50: number;
            p95: number;
            p99: number;
        };
    };
    errorPatterns: ErrorPattern[];
    featureUsage: Record<string, FeatureUsageMetrics>;
}
export interface UserJourney {
    pattern: string;
    frequency: number;
    avgDuration: number;
    conversionRate: number;
    dropoffPoints?: Array<{
        step: string;
        dropoffRate: number;
        reason: string;
    }>;
    steps?: JourneyStep[];
}
export interface JourneyStep {
    timestamp: string;
    action: string;
    duration: number;
    metadata?: Record<string, any>;
}
export interface ErrorPattern {
    error: string;
    frequency: number;
    affectedUsers: number;
    browsers?: string[];
    regions?: string[];
    pages?: string[];
    timePattern?: string;
    userImpact: 'LOW' | 'MEDIUM' | 'HIGH';
}
export interface FeatureUsageMetrics {
    usage: number;
    satisfaction?: number;
    clickthrough?: number;
    conversion?: number;
}
export interface LoadPattern {
    dailyPattern: {
        hourly: Array<{
            hour: number;
            rps: number;
        }>;
        peakHours: number[];
        lowTrafficHours: number[];
    };
    weeklyPattern: Record<string, {
        rps: number;
        conversionRate: number;
    }>;
    seasonalPattern?: Record<string, {
        rps: number;
        spike: number;
    }>;
    endpointDistribution: Record<string, number>;
    userBehaviorPatterns: Record<string, any>;
}
export interface AnomalyDetection {
    type: 'ERROR_RATE_SPIKE' | 'LATENCY_DEGRADATION' | 'USER_BEHAVIOR_ANOMALY' | 'THROUGHPUT_DROP';
    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    details: {
        current: number;
        baseline: number;
        deviation: number;
        magnitude: number;
        confidence: number;
    };
    affectedUsers?: number;
    affectedEndpoints?: string[];
    recommendation: string;
    hypothesis?: string;
}
export declare class ProductionIntelligenceAgent extends BaseAgent {
    private readonly config;
    private baselineMetrics;
    private monitoringClients;
    constructor(config: ProductionIntelligenceConfig);
    protected initializeComponents(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    private performIncidentReplay;
    private generateIncidentTestScenario;
    private performRUMAnalysis;
    private analyzeUserJourneys;
    private identifyErrorPatterns;
    private generatePerformanceInsights;
    private generateTestsFromRUMData;
    private performAnomalyDetection;
    private detectErrorRateSpike;
    private detectLatencyDegradation;
    private detectBehaviorAnomaly;
    private calculateConfidence;
    private performLoadPatternAnalysis;
    private extractLoadPattern;
    private generateLoadTestScript;
    private generateLoadTestRecommendations;
    private performFeatureUsageAnalytics;
    private fetchFeatureUsageData;
    private analyzeFeaturePriority;
    private identifyUnusedFeatures;
    private generateTestsFromIncidents;
    private generateTestsFromRUM;
    private analyzeProductionVsStaging;
    private initializeMonitoringClients;
    private loadBaselineMetrics;
    private registerProductionEventHandlers;
    private fetchRUMData;
    private fetchIncidents;
    private fetchProductionMetric;
    private fetchStagingMetric;
}
//# sourceMappingURL=ProductionIntelligenceAgent.d.ts.map