@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/chaos-resilience/services/load-tester.ts

@@ -1,799 +0,0 @@
-/**
- * Agentic QE v3 - Load Testing Service
- * Implements ILoadTestingService for performance and stress testing
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { Result, ok, err } from '../../../shared/types';
-import { HttpClient, RequestOptions } from '../../../shared/http';
-import { MemoryBackend } from '../../../kernel/interfaces';
-import {
-  LoadTest,
-  LoadTestType,
-  LoadTestResult,
-  TimelinePoint,
-  LoadTestError,
-  AssertionResult,
-  LoadAssertion,
-  TrafficSample,
-  LoadProfile,
-  LoadScenario,
-  ILoadTestingService,
-} from '../interfaces';
-
-/**
- * Configuration for the load tester service
- */
-export interface LoadTesterConfig {
-  defaultTimeout: number;
-  maxVirtualUsers: number;
-  reportingInterval: number;
-  enableDetailedMetrics: boolean;
-  connectionPoolSize: number;
-}
-
-const DEFAULT_CONFIG: LoadTesterConfig = {
-  defaultTimeout: 300000, // 5 minutes
-  maxVirtualUsers: 1000,
-  reportingInterval: 1000, // 1 second
-  enableDetailedMetrics: true,
-  connectionPoolSize: 100,
-};
-
-/**
- * Mutable versions for internal tracking
- */
-interface MutableLoadTestSummary {
-  totalRequests: number;
-  successfulRequests: number;
-  failedRequests: number;
-  requestsPerSecond: number;
-  avgResponseTime: number;
-  p50ResponseTime: number;
-  p95ResponseTime: number;
-  p99ResponseTime: number;
-  maxResponseTime: number;
-  errorRate: number;
-}
-
-interface MutableLoadTestResult {
-  testId: string;
-  status: 'completed' | 'failed' | 'aborted';
-  duration: number;
-  summary: MutableLoadTestSummary;
-  timeline: TimelinePoint[];
-  errors: LoadTestError[];
-  assertionResults: AssertionResult[];
-}
-
-interface MutableLoadTestError {
-  type: string;
-  message: string;
-  count: number;
-  firstOccurrence: Date;
-  lastOccurrence: Date;
-}
-
-/**
- * Result of a single HTTP request during load testing
- */
-interface RequestResult {
-  status: number;
-  latency: number;
-  success: boolean;
-  error?: string;
-  timestamp: number;
-}
-
-/**
- * Load Testing Service Implementation
- * Manages load tests, stress tests, and performance benchmarking
- */
-export class LoadTesterService implements ILoadTestingService {
-  private readonly config: LoadTesterConfig;
-  private readonly activeTests: Map<string, LoadTestExecution> = new Map();
-  private readonly httpClient: HttpClient;
-
-  constructor(
-    private readonly memory: MemoryBackend,
-    config: Partial<LoadTesterConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.httpClient = new HttpClient();
-  }
-
-  /**
-   * Create a new load test
-   */
-  async createTest(test: LoadTest): Promise<Result<string>> {
-    try {
-      // Validate test configuration
-      const validationResult = this.validateTest(test);
-      if (!validationResult.success) {
-        return err(validationResult.error);
-      }
-
-      // Store test configuration
-      await this.memory.set(
-        `loadtest:tests:${test.id}`,
-        test,
-        { namespace: 'chaos-resilience', persist: true }
-      );
-
-      return ok(test.id);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Run a load test
-   */
-  async runTest(testId: string): Promise<Result<LoadTestResult>> {
-    try {
-      // Load test configuration
-      const test = await this.memory.get<LoadTest>(`loadtest:tests:${testId}`);
-      if (!test) {
-        return err(new Error(`Load test not found: ${testId}`));
-      }
-
-      // Check if test is already running
-      if (this.activeTests.has(testId)) {
-        return err(new Error(`Load test ${testId} is already running`));
-      }
-
-      // Check virtual user limit
-      if (test.profile.virtualUsers.max > this.config.maxVirtualUsers) {
-        return err(
-          new Error(
-            `Virtual users (${test.profile.virtualUsers.max}) exceeds maximum (${this.config.maxVirtualUsers})`
-          )
-        );
-      }
-
-      // Create test execution
-      const execution = this.createExecution(test);
-      this.activeTests.set(testId, execution);
-
-      try {
-        // Execute the load test based on type
-        await this.executeLoadTest(execution, test);
-
-        // Evaluate assertions
-        execution.result.assertionResults = this.evaluateAssertions(
-          test.assertions,
-          execution.result.summary
-        );
-
-        // Determine final status
-        execution.result.status = this.determineTestStatus(execution.result);
-
-        return ok(this.finalizeExecution(execution));
-      } catch (error) {
-        execution.result.status = 'failed';
-        execution.result.errors.push({
-          type: 'execution_error',
-          message: error instanceof Error ? error.message : String(error),
-          count: 1,
-          firstOccurrence: new Date(),
-          lastOccurrence: new Date(),
-        });
-        return ok(this.finalizeExecution(execution));
-      } finally {
-        this.activeTests.delete(testId);
-      }
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Stop a running test
-   */
-  async stopTest(testId: string): Promise<Result<LoadTestResult>> {
-    try {
-      const execution = this.activeTests.get(testId);
-      if (!execution) {
-        return err(new Error(`No active load test found: ${testId}`));
-      }
-
-      execution.aborted = true;
-      execution.result.status = 'aborted';
-
-      return ok(this.finalizeExecution(execution));
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get real-time metrics for a running test
-   */
-  async getRealtimeMetrics(testId: string): Promise<Result<TimelinePoint>> {
-    try {
-      const execution = this.activeTests.get(testId);
-      if (!execution) {
-        return err(new Error(`No active load test found: ${testId}`));
-      }
-
-      const latestPoint = execution.result.timeline[execution.result.timeline.length - 1];
-      if (!latestPoint) {
-        return err(new Error('No metrics available yet'));
-      }
-
-      return ok(latestPoint);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Generate a load test from traffic sample
-   */
-  async generateFromTraffic(
-    trafficSample: TrafficSample,
-    multiplier: number
-  ): Promise<Result<LoadTest>> {
-    try {
-      if (trafficSample.requests.length === 0) {
-        return err(new Error('Traffic sample contains no requests'));
-      }
-
-      if (multiplier <= 0) {
-        return err(new Error('Multiplier must be positive'));
-      }
-
-      // Analyze traffic patterns
-      const totalFrequency = trafficSample.requests.reduce((sum, r) => sum + r.frequency, 0);
-      const avgResponseTime =
-        trafficSample.requests.reduce((sum, r) => sum + r.avgResponseTime * r.frequency, 0) /
-        totalFrequency;
-
-      // Generate scenarios from traffic
-      const scenarios: LoadScenario[] = trafficSample.requests.map((request) => ({
-        name: `${request.method} ${request.url}`,
-        weight: request.frequency / totalFrequency,
-        steps: [
-          {
-            type: 'request' as const,
-            target: {
-              url: request.url,
-              method: request.method,
-            },
-          },
-          {
-            type: 'think' as const,
-            duration: Math.max(100, avgResponseTime * 0.5), // Think time based on response time
-          },
-        ],
-      }));
-
-      // Calculate virtual users based on traffic volume and multiplier
-      const rps = totalFrequency / trafficSample.duration;
-      const targetRps = rps * multiplier;
-      const estimatedVirtualUsers = Math.ceil(targetRps * (avgResponseTime / 1000));
-
-      const profile: LoadProfile = {
-        virtualUsers: {
-          start: Math.ceil(estimatedVirtualUsers * 0.1),
-          max: Math.min(estimatedVirtualUsers, this.config.maxVirtualUsers),
-          pattern: 'ramp',
-        },
-        duration: Math.max(60000, trafficSample.duration * multiplier), // At least 1 minute
-        rampUp: 30000, // 30 second ramp up
-        rampDown: 15000, // 15 second ramp down
-      };
-
-      // Generate assertions based on baseline performance
-      const assertions: LoadAssertion[] = [
-        {
-          metric: 'p95',
-          operator: 'lt',
-          value: avgResponseTime * 2, // P95 should be within 2x baseline
-        },
-        {
-          metric: 'error-rate',
-          operator: 'lt',
-          value: 5, // Less than 5% error rate
-        },
-        {
-          metric: 'throughput',
-          operator: 'gte',
-          value: targetRps * 0.9, // At least 90% of target throughput
-        },
-      ];
-
-      const loadTestType: LoadTestType = multiplier > 5 ? 'stress' : 'load';
-
-      const loadTest: LoadTest = {
-        id: uuidv4(),
-        name: `Generated from ${trafficSample.source} (${multiplier}x)`,
-        type: loadTestType,
-        target: {
-          url: trafficSample.requests[0].url,
-          method: trafficSample.requests[0].method,
-        },
-        profile,
-        scenarios,
-        assertions,
-      };
-
-      return ok(loadTest);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private validateTest(test: LoadTest): Result<void> {
-    if (!test.id) {
-      return err(new Error('Test ID is required'));
-    }
-
-    if (!test.name) {
-      return err(new Error('Test name is required'));
-    }
-
-    if (!test.target || !test.target.url) {
-      return err(new Error('Test target URL is required'));
-    }
-
-    if (!test.profile) {
-      return err(new Error('Test profile is required'));
-    }
-
-    if (test.profile.virtualUsers.max <= 0) {
-      return err(new Error('Maximum virtual users must be positive'));
-    }
-
-    if (test.profile.duration <= 0) {
-      return err(new Error('Test duration must be positive'));
-    }
-
-    return ok(undefined);
-  }
-
-  private createExecution(test: LoadTest): LoadTestExecution {
-    return {
-      testId: test.id,
-      startTime: new Date(),
-      aborted: false,
-      result: {
-        testId: test.id,
-        status: 'completed',
-        duration: 0,
-        summary: this.createEmptySummary(),
-        timeline: [],
-        errors: [],
-        assertionResults: [],
-      },
-    };
-  }
-
-  private createEmptySummary(): MutableLoadTestSummary {
-    return {
-      totalRequests: 0,
-      successfulRequests: 0,
-      failedRequests: 0,
-      requestsPerSecond: 0,
-      avgResponseTime: 0,
-      p50ResponseTime: 0,
-      p95ResponseTime: 0,
-      p99ResponseTime: 0,
-      maxResponseTime: 0,
-      errorRate: 0,
-    };
-  }
-
-  private async executeLoadTest(
-    execution: LoadTestExecution,
-    test: LoadTest
-  ): Promise<void> {
-    const startTime = Date.now();
-    const duration = test.profile.duration;
-    const responseTimes: number[] = [];
-    const errorMap: Map<string, MutableLoadTestError> = new Map();
-
-    // Determine test execution strategy based on type
-    const strategy = this.getExecutionStrategy(test.type);
-
-    // Main execution loop
-    while (Date.now() - startTime < duration && !execution.aborted) {
-      const elapsedTime = Date.now() - startTime;
-      const currentVUs = this.calculateCurrentVirtualUsers(test.profile, elapsedTime, duration);
-
-      // Simulate requests based on current VUs
-      const batchResults = await this.executeBatch(test, currentVUs, strategy);
-
-      // Collect metrics
-      responseTimes.push(...batchResults.responseTimes);
-
-      // Track errors
-      for (const error of batchResults.errors) {
-        const existing = errorMap.get(error);
-        if (existing) {
-          existing.count++;
-          existing.lastOccurrence = new Date();
-        } else {
-          errorMap.set(error, {
-            type: 'request_error',
-            message: error,
-            count: 1,
-            firstOccurrence: new Date(),
-            lastOccurrence: new Date(),
-          });
-        }
-      }
-
-      // Update summary
-      execution.result.summary.totalRequests += batchResults.totalRequests;
-      execution.result.summary.successfulRequests += batchResults.successfulRequests;
-      execution.result.summary.failedRequests += batchResults.failedRequests;
-
-      // Record timeline point
-      const timelinePoint: TimelinePoint = {
-        timestamp: new Date(),
-        virtualUsers: currentVUs,
-        requestsPerSecond: batchResults.totalRequests,
-        avgResponseTime:
-          batchResults.responseTimes.length > 0
-            ? batchResults.responseTimes.reduce((a, b) => a + b, 0) /
-              batchResults.responseTimes.length
-            : 0,
-        errorRate:
-          batchResults.totalRequests > 0
-            ? (batchResults.failedRequests / batchResults.totalRequests) * 100
-            : 0,
-      };
-      execution.result.timeline.push(timelinePoint);
-
-      // Wait for reporting interval
-      await this.sleep(this.config.reportingInterval);
-    }
-
-    // Calculate final metrics
-    execution.result.duration = Date.now() - startTime;
-    execution.result.errors = Array.from(errorMap.values());
-
-    if (responseTimes.length > 0) {
-      const sorted = responseTimes.sort((a, b) => a - b);
-      execution.result.summary.avgResponseTime =
-        sorted.reduce((a, b) => a + b, 0) / sorted.length;
-      execution.result.summary.p50ResponseTime = this.percentile(sorted, 50);
-      execution.result.summary.p95ResponseTime = this.percentile(sorted, 95);
-      execution.result.summary.p99ResponseTime = this.percentile(sorted, 99);
-      execution.result.summary.maxResponseTime = sorted[sorted.length - 1];
-    }
-
-    execution.result.summary.requestsPerSecond =
-      execution.result.summary.totalRequests / (execution.result.duration / 1000);
-    execution.result.summary.errorRate =
-      execution.result.summary.totalRequests > 0
-        ? (execution.result.summary.failedRequests / execution.result.summary.totalRequests) * 100
-        : 0;
-  }
-
-  private getExecutionStrategy(type: LoadTestType): ExecutionStrategy {
-    switch (type) {
-      case 'load':
-        return { requestMultiplier: 1.0, errorInjectionRate: 0 };
-      case 'stress':
-        return { requestMultiplier: 1.5, errorInjectionRate: 0.01 };
-      case 'spike':
-        return { requestMultiplier: 3.0, errorInjectionRate: 0.02 };
-      case 'soak':
-        return { requestMultiplier: 0.8, errorInjectionRate: 0 };
-      case 'breakpoint':
-        return { requestMultiplier: 2.0, errorInjectionRate: 0.05 };
-      default:
-        return { requestMultiplier: 1.0, errorInjectionRate: 0 };
-    }
-  }
-
-  private calculateCurrentVirtualUsers(
-    profile: LoadProfile,
-    elapsedTime: number,
-    duration: number
-  ): number {
-    const { virtualUsers, rampUp = 0, rampDown = 0 } = profile;
-    const { start, max, pattern } = virtualUsers;
-
-    switch (pattern) {
-      case 'constant':
-        return max;
-
-      case 'ramp':
-        if (elapsedTime < rampUp) {
-          // Ramp up phase
-          return Math.round(start + (max - start) * (elapsedTime / rampUp));
-        } else if (elapsedTime > duration - rampDown) {
-          // Ramp down phase
-          const rampDownProgress = (duration - elapsedTime) / rampDown;
-          return Math.round(start + (max - start) * rampDownProgress);
-        }
-        return max;
-
-      case 'step':
-        const steps = 5;
-        const stepDuration = duration / steps;
-        const currentStep = Math.floor(elapsedTime / stepDuration);
-        const stepSize = (max - start) / steps;
-        return Math.round(start + stepSize * currentStep);
-
-      case 'spike':
-        // Create periodic spikes
-        const spikeInterval = 30000; // 30 seconds
-        const spikeDuration = 5000; // 5 second spike
-        const timeInCycle = elapsedTime % spikeInterval;
-        if (timeInCycle < spikeDuration) {
-          return max;
-        }
-        return start;
-
-      default:
-        return max;
-    }
-  }
-
-  private async executeBatch(
-    test: LoadTest,
-    virtualUsers: number,
-    strategy: ExecutionStrategy
-  ): Promise<BatchResult> {
-    const totalRequests = Math.round(virtualUsers * strategy.requestMultiplier);
-    const concurrency = Math.min(totalRequests, this.config.connectionPoolSize);
-
-    // Create request batches for concurrency control
-    const batches = this.createBatches(totalRequests, concurrency);
-    const allResults: RequestResult[] = [];
-
-    for (const batch of batches) {
-      const batchStart = Date.now();
-
-      // Execute batch of requests in parallel
-      const batchResults = await Promise.all(
-        batch.map(() => this.executeRequest(test, strategy))
-      );
-
-      allResults.push(...batchResults);
-
-      // Rate limiting: ensure we don't exceed target requests per second
-      const elapsed = Date.now() - batchStart;
-      const targetTime = (1000 / Math.max(virtualUsers, 1)) * batch.length;
-      if (elapsed < targetTime) {
-        await this.sleep(targetTime - elapsed);
-      }
-    }
-
-    // Aggregate results
-    const responseTimes = allResults.filter(r => r.success).map(r => r.latency);
-    const errors = allResults.filter(r => !r.success).map(r => r.error || 'Unknown error');
-
-    return {
-      totalRequests: allResults.length,
-      successfulRequests: allResults.filter(r => r.success).length,
-      failedRequests: allResults.filter(r => !r.success).length,
-      responseTimes,
-      errors,
-    };
-  }
-
-  /**
-   * Execute a single HTTP request and measure latency
-   */
-  private async executeRequest(
-    test: LoadTest,
-    strategy: ExecutionStrategy
-  ): Promise<RequestResult> {
-    const start = Date.now();
-    const timestamp = start;
-
-    // Apply error injection for testing (optional, based on strategy)
-    if (strategy.errorInjectionRate > 0 && Math.random() < strategy.errorInjectionRate) {
-      return {
-        status: 0,
-        latency: Date.now() - start,
-        success: false,
-        error: 'Simulated error injection',
-        timestamp,
-      };
-    }
-
-    try {
-      const { url, method = 'GET', headers, body } = test.target;
-
-      const requestOptions: RequestOptions = {
-        headers,
-        timeout: this.config.defaultTimeout,
-        retries: 0, // No retries during load test to get accurate metrics
-        circuitBreaker: false, // Disable circuit breaker for load testing
-      };
-
-      // Execute request based on method
-      let result;
-      switch (method.toUpperCase()) {
-        case 'POST':
-          result = await this.httpClient.post(url, body, requestOptions);
-          break;
-        case 'PUT':
-          result = await this.httpClient.put(url, body, requestOptions);
-          break;
-        case 'DELETE':
-          result = await this.httpClient.delete(url, requestOptions);
-          break;
-        case 'GET':
-        default:
-          result = await this.httpClient.get(url, requestOptions);
-          break;
-      }
-
-      if (result.success) {
-        const response = result.value;
-        return {
-          status: response.status,
-          latency: Date.now() - start,
-          success: response.ok,
-          error: response.ok ? undefined : `HTTP ${response.status}: ${response.statusText}`,
-          timestamp,
-        };
-      } else {
-        return {
-          status: result.error.status ?? 0,
-          latency: Date.now() - start,
-          success: false,
-          error: result.error.message,
-          timestamp,
-        };
-      }
-    } catch (error) {
-      return {
-        status: 0,
-        latency: Date.now() - start,
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp,
-      };
-    }
-  }
-
-  /**
-   * Create batches of requests for concurrency control
-   */
-  private createBatches(totalRequests: number, concurrency: number): number[][] {
-    const batches: number[][] = [];
-    let remaining = totalRequests;
-
-    while (remaining > 0) {
-      const batchSize = Math.min(remaining, concurrency);
-      batches.push(Array.from({ length: batchSize }, (_, i) => i));
-      remaining -= batchSize;
-    }
-
-    return batches;
-  }
-
-  private percentile(sorted: number[], p: number): number {
-    if (sorted.length === 0) return 0;
-    const index = Math.ceil((p / 100) * sorted.length) - 1;
-    return sorted[Math.max(0, Math.min(index, sorted.length - 1))];
-  }
-
-  private evaluateAssertions(
-    assertions: LoadAssertion[],
-    summary: MutableLoadTestSummary
-  ): AssertionResult[] {
-    return assertions.map((assertion) => {
-      const actualValue = this.getMetricValue(assertion.metric, summary);
-      const passed = this.checkAssertion(assertion, actualValue);
-
-      return {
-        assertion,
-        passed,
-        actualValue,
-      };
-    });
-  }
-
-  private getMetricValue(metric: LoadAssertion['metric'], summary: MutableLoadTestSummary): number {
-    switch (metric) {
-      case 'response-time':
-        return summary.avgResponseTime;
-      case 'throughput':
-        return summary.requestsPerSecond;
-      case 'error-rate':
-        return summary.errorRate;
-      case 'p95':
-        return summary.p95ResponseTime;
-      case 'p99':
-        return summary.p99ResponseTime;
-      default:
-        return 0;
-    }
-  }
-
-  private checkAssertion(assertion: LoadAssertion, actual: number): boolean {
-    switch (assertion.operator) {
-      case 'lt':
-        return actual < assertion.value;
-      case 'gt':
-        return actual > assertion.value;
-      case 'lte':
-        return actual <= assertion.value;
-      case 'gte':
-        return actual >= assertion.value;
-      default:
-        return false;
-    }
-  }
-
-  private determineTestStatus(result: MutableLoadTestResult): 'completed' | 'failed' | 'aborted' {
-    if (result.status === 'aborted') {
-      return 'aborted';
-    }
-
-    // Check if any assertions failed
-    const failedAssertions = result.assertionResults.filter((a) => !a.passed);
-    if (failedAssertions.length > 0) {
-      return 'failed';
-    }
-
-    // Check if error rate is too high (more than 10%)
-    if (result.summary.errorRate > 10) {
-      return 'failed';
-    }
-
-    return 'completed';
-  }
-
-  private finalizeExecution(execution: LoadTestExecution): LoadTestResult {
-    // Convert to readonly result
-    const result: LoadTestResult = {
-      testId: execution.result.testId,
-      status: execution.result.status,
-      duration: execution.result.duration,
-      summary: execution.result.summary,
-      timeline: execution.result.timeline,
-      errors: execution.result.errors,
-      assertionResults: execution.result.assertionResults,
-    };
-
-    // Store result in memory
-    this.memory.set(
-      `loadtest:results:${execution.testId}:${Date.now()}`,
-      result,
-      { namespace: 'chaos-resilience', persist: true }
-    );
-
-    return result;
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-}
-
-/**
- * Internal types
- */
-interface LoadTestExecution {
-  testId: string;
-  startTime: Date;
-  aborted: boolean;
-  result: MutableLoadTestResult;
-}
-
-interface ExecutionStrategy {
-  requestMultiplier: number;
-  errorInjectionRate: number;
-}
-
-interface BatchResult {
-  totalRequests: number;
-  successfulRequests: number;
-  failedRequests: number;
-  responseTimes: number[];
-  errors: string[];
-}