@agentic-qe/v3 3.0.0-alpha.3

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

@@ -0,0 +1,799 @@
+/**
+ * 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[];
+}