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

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

/**
 * PerformanceTesterAgent - Load testing and bottleneck detection specialist
 *
 * Implements load testing orchestration (JMeter, K6, Gatling, Artillery),
 * bottleneck detection, resource monitoring, SLA validation, performance
 * regression detection, and load pattern generation.
 *
 * Based on SPARC methodology and AQE Fleet specification
 */
import { BaseAgent, BaseAgentConfig } from './BaseAgent';
import { QETask } from '../types';
export interface PerformanceTesterConfig extends BaseAgentConfig {
    tools?: {
        loadTesting?: 'k6' | 'jmeter' | 'gatling' | 'artillery';
        monitoring?: string[];
        apm?: 'newrelic' | 'datadog' | 'dynatrace';
    };
    thresholds?: {
        maxLatencyP95: number;
        maxLatencyP99: number;
        minThroughput: number;
        maxErrorRate: number;
        maxCpuUsage: number;
        maxMemoryUsage: number;
    };
    loadProfile?: {
        virtualUsers: number;
        duration: number;
        rampUpTime: number;
        pattern: 'constant' | 'ramp-up' | 'spike' | 'stress' | 'soak';
    };
}
export interface LoadTestConfig {
    targetUrl: string;
    loadProfile: LoadProfile;
    thresholds: PerformanceThresholds;
    monitoring?: MonitoringConfig;
}
export interface LoadProfile {
    virtualUsers: number;
    duration: number;
    rampUpTime: number;
    pattern: 'constant' | 'ramp-up' | 'spike' | 'stress' | 'soak';
    endpoints?: EndpointDistribution[];
}
export interface EndpointDistribution {
    path: string;
    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    percentage: number;
    payload?: any;
}
export interface PerformanceThresholds {
    maxLatencyP95: number;
    maxLatencyP99: number;
    minThroughput: number;
    maxErrorRate: number;
    maxCpuUsage?: number;
    maxMemoryUsage?: number;
}
export interface MonitoringConfig {
    enabled: boolean;
    interval: number;
    metrics: string[];
}
export interface LoadTestResult {
    id: string;
    startTime: Date;
    endTime: Date;
    duration: number;
    metrics: PerformanceMetrics;
    bottlenecks: Bottleneck[];
    slaViolations: SLAViolation[];
    recommendations: string[];
}
export interface PerformanceMetrics {
    requests: {
        total: number;
        successful: number;
        failed: number;
        errorRate: number;
    };
    latency: {
        min: number;
        max: number;
        mean: number;
        p50: number;
        p95: number;
        p99: number;
    };
    throughput: {
        requestsPerSecond: number;
        bytesPerSecond: number;
    };
    resources: {
        cpu: ResourceUsage;
        memory: ResourceUsage;
        network: ResourceUsage;
        disk?: ResourceUsage;
    };
}
export interface ResourceUsage {
    current: number;
    average: number;
    peak: number;
    unit: string;
}
export interface Bottleneck {
    type: 'CPU' | 'MEMORY' | 'IO' | 'DATABASE' | 'NETWORK' | 'APPLICATION';
    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    location: string;
    description: string;
    metrics: Record<string, number>;
    remediation: string[];
    impactEstimate: string;
}
export interface SLAViolation {
    metric: string;
    threshold: number;
    actual: number;
    violation: number;
    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    duration: number;
}
export interface PerformanceBaseline {
    timestamp: Date;
    metrics: PerformanceMetrics;
    loadProfile: LoadProfile;
    version: string;
    environment: string;
}
export interface RegressionAnalysis {
    current: PerformanceMetrics;
    baseline: PerformanceMetrics;
    regressions: PerformanceRegression[];
    improvements: PerformanceImprovement[];
    verdict: 'PASS' | 'FAIL' | 'WARNING';
}
export interface PerformanceRegression {
    metric: string;
    baseline: number;
    current: number;
    degradation: number;
    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
}
export interface PerformanceImprovement {
    metric: string;
    baseline: number;
    current: number;
    improvement: number;
}
export declare class PerformanceTesterAgent extends BaseAgent {
    private readonly config;
    private loadTestingClient?;
    private monitoringClient?;
    private activeTests;
    private baselines;
    constructor(config: PerformanceTesterConfig);
    protected initializeComponents(): Promise<void>;
    protected performTask(task: QETask): Promise<any>;
    protected loadKnowledge(): Promise<void>;
    protected cleanup(): Promise<void>;
    private runLoadTest;
    private generateLoadTestScript;
    private generateK6Script;
    private generateStages;
    private generateJMeterScript;
    private generateGatlingScript;
    private generateArtilleryScript;
    private executeLoadTest;
    private collectMonitoringData;
    private analyzeLoadTestResults;
    private detectBottlenecks;
    private analyzeBottlenecks;
    private identifyLatencyBottleneck;
    private calculateSeverity;
    private validateSLA;
    private checkSLAViolationsAsync;
    private checkSLAViolations;
    private calculateViolationSeverity;
    private detectRegressions;
    private calculateRegressionSeverity;
    private establishBaseline;
    private loadBaselines;
    private generateLoadPattern;
    private initializeLoadTestingClient;
    private initializeMonitoringClient;
    private registerPerformanceEventHandlers;
    private parseTestConfig;
    private storeTestResults;
    private generateRecommendations;
    private analyzePerformance;
    private getDefaultThresholds;
}
//# sourceMappingURL=PerformanceTesterAgent.d.ts.map