qa360 2.1.2 → 2.1.4

package/core/src/serve/metrics-collector.ts

@@ -0,0 +1,386 @@
+/**
+ * QA360 Metrics Collector
+ * Génère des métriques au format OpenMetrics/Prometheus
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+export interface MetricValue {
+  name: string;
+  value: number;
+  labels?: Record<string, string>;
+  help?: string;
+  type?: 'counter' | 'gauge' | 'histogram' | 'summary';
+}
+
+export class MetricsCollector {
+  private startTime: number;
+
+  constructor() {
+    this.startTime = Date.now();
+  }
+
+  async collect(): Promise<string> {
+    const metrics = await this.gatherMetrics();
+    return this.formatOpenMetrics(metrics);
+  }
+
+  private async gatherMetrics(): Promise<MetricValue[]> {
+    const metrics: MetricValue[] = [];
+
+    // System metrics
+    metrics.push({
+      name: 'qa360_uptime_seconds',
+      value: Math.floor((Date.now() - this.startTime) / 1000),
+      help: 'QA360 server uptime in seconds',
+      type: 'counter'
+    });
+
+    // Version info
+    const version = this.getVersion();
+    metrics.push({
+      name: 'qa360_info',
+      value: 1,
+      labels: { version },
+      help: 'QA360 version information',
+      type: 'gauge'
+    });
+
+    // Run metrics from history
+    const runMetrics = await this.collectRunMetrics();
+    metrics.push(...runMetrics);
+
+    // Gate metrics from last run
+    const gateMetrics = await this.collectGateMetrics();
+    metrics.push(...gateMetrics);
+
+    // Security metrics from last run
+    const securityMetrics = await this.collectSecurityMetrics();
+    metrics.push(...securityMetrics);
+
+    // Performance metrics from last run
+    const perfMetrics = await this.collectPerformanceMetrics();
+    metrics.push(...perfMetrics);
+
+    return metrics;
+  }
+
+  private async collectRunMetrics(): Promise<MetricValue[]> {
+    const metrics: MetricValue[] = [];
+    
+    try {
+      const runsDir = join(process.cwd(), '.qa360', 'runs');
+      if (!existsSync(runsDir)) {
+        return [
+          { name: 'qa360_runs_total', value: 0, help: 'Total number of QA360 runs', type: 'counter' },
+          { name: 'qa360_last_run_trust_score', value: 0, help: 'Trust score of last run', type: 'gauge' }
+        ];
+      }
+
+      const fs = require('fs');
+      const runFiles = fs.readdirSync(runsDir).filter((f: string) => f.endsWith('.json'));
+      
+      metrics.push({
+        name: 'qa360_runs_total',
+        value: runFiles.length,
+        help: 'Total number of QA360 runs',
+        type: 'counter'
+      });
+
+      // Get last run metrics
+      if (runFiles.length > 0) {
+        const lastRunFile = runFiles.sort().pop();
+        const lastRunPath = join(runsDir, lastRunFile!);
+        const lastRun = JSON.parse(fs.readFileSync(lastRunPath, 'utf8'));
+        
+        metrics.push({
+          name: 'qa360_last_run_trust_score',
+          value: lastRun.trustScore || lastRun.trust_score || 0,
+          help: 'Trust score of last run',
+          type: 'gauge'
+        });
+
+        metrics.push({
+          name: 'qa360_last_run_timestamp',
+          value: new Date(lastRun.timestamp || lastRun.ts || 0).getTime() / 1000,
+          help: 'Timestamp of last run',
+          type: 'gauge'
+        });
+      } else {
+        metrics.push({
+          name: 'qa360_last_run_trust_score',
+          value: 0,
+          help: 'Trust score of last run',
+          type: 'gauge'
+        });
+      }
+
+    } catch {
+      metrics.push({
+        name: 'qa360_runs_total',
+        value: 0,
+        help: 'Total number of QA360 runs',
+        type: 'counter'
+      });
+    }
+
+    return metrics;
+  }
+
+  private async collectGateMetrics(): Promise<MetricValue[]> {
+    const metrics: MetricValue[] = [];
+    
+    try {
+      const lastRun = await this.getLastRunData();
+      if (!lastRun) return metrics;
+
+      // Gate duration metrics
+      const gates = ['api', 'ui', 'perf', 'a11y', 'sast', 'deps', 'secrets', 'dast'];
+      
+      for (const gate of gates) {
+        const gateData = lastRun[gate] || lastRun.gates?.[gate];
+        if (gateData) {
+          const duration = gateData.duration_ms || gateData.duration || 0;
+          metrics.push({
+            name: 'qa360_gate_duration_ms',
+            value: duration,
+            labels: { gate },
+            help: 'Duration of gate execution in milliseconds',
+            type: 'gauge'
+          });
+
+          const failures = gateData.failures || (gateData.success === false ? 1 : 0);
+          metrics.push({
+            name: 'qa360_gate_failures_total',
+            value: failures,
+            labels: { gate },
+            help: 'Number of gate failures',
+            type: 'counter'
+          });
+        }
+      }
+
+    } catch {
+      // Return empty metrics on error
+    }
+
+    return metrics;
+  }
+
+  private async collectSecurityMetrics(): Promise<MetricValue[]> {
+    const metrics: MetricValue[] = [];
+    
+    try {
+      const lastRun = await this.getLastRunData();
+      if (!lastRun?.security) return metrics;
+
+      // SAST findings
+      if (lastRun.security.sast) {
+        const sastData = lastRun.security.sast;
+        const highFindings = sastData.max_high?.actual || 0;
+        const criticalFindings = sastData.max_critical?.actual || 0;
+        const mediumFindings = sastData.max_medium?.actual || 0;
+
+        metrics.push({
+          name: 'qa360_security_findings',
+          value: highFindings,
+          labels: { kind: 'sast_high' },
+          help: 'Number of security findings by type',
+          type: 'gauge'
+        });
+
+        metrics.push({
+          name: 'qa360_security_findings',
+          value: criticalFindings,
+          labels: { kind: 'sast_critical' },
+          help: 'Number of security findings by type',
+          type: 'gauge'
+        });
+
+        metrics.push({
+          name: 'qa360_security_findings',
+          value: mediumFindings,
+          labels: { kind: 'sast_medium' },
+          help: 'Number of security findings by type',
+          type: 'gauge'
+        });
+      }
+
+      // DAST findings
+      if (lastRun.security.dast) {
+        const dastData = lastRun.security.dast;
+        const dastHigh = dastData.max_high?.actual || 0;
+        
+        metrics.push({
+          name: 'qa360_security_findings',
+          value: dastHigh,
+          labels: { kind: 'dast_high' },
+          help: 'Number of security findings by type',
+          type: 'gauge'
+        });
+      }
+
+      // Dependencies vulnerabilities
+      if (lastRun.security.deps) {
+        const depsData = lastRun.security.deps;
+        const depsHigh = depsData.max_high?.actual || 0;
+        
+        metrics.push({
+          name: 'qa360_security_findings',
+          value: depsHigh,
+          labels: { kind: 'deps_high' },
+          help: 'Number of security findings by type',
+          type: 'gauge'
+        });
+      }
+
+      // Secrets findings
+      if (lastRun.security.secrets) {
+        const secretsData = lastRun.security.secrets;
+        const secretsFindings = secretsData.max_findings?.actual || 0;
+        
+        metrics.push({
+          name: 'qa360_security_findings',
+          value: secretsFindings,
+          labels: { kind: 'secrets' },
+          help: 'Number of security findings by type',
+          type: 'gauge'
+        });
+      }
+
+    } catch {
+      // Return empty metrics on error
+    }
+
+    return metrics;
+  }
+
+  private async collectPerformanceMetrics(): Promise<MetricValue[]> {
+    const metrics: MetricValue[] = [];
+    
+    try {
+      const lastRun = await this.getLastRunData();
+      if (!lastRun?.perf && !lastRun?.performance) return metrics;
+
+      const perfData = lastRun.perf || lastRun.performance;
+      
+      // Performance percentiles
+      const p95 = perfData.p95_ms?.actual || perfData.p95 || 0;
+      const p90 = perfData.p90_ms?.actual || perfData.p90 || 0;
+      const p50 = perfData.p50_ms?.actual || perfData.p50 || 0;
+
+      metrics.push({
+        name: 'qa360_perf_p95_ms',
+        value: p95,
+        help: 'Performance P95 latency in milliseconds',
+        type: 'gauge'
+      });
+
+      metrics.push({
+        name: 'qa360_perf_p90_ms',
+        value: p90,
+        help: 'Performance P90 latency in milliseconds',
+        type: 'gauge'
+      });
+
+      metrics.push({
+        name: 'qa360_perf_p50_ms',
+        value: p50,
+        help: 'Performance P50 latency in milliseconds',
+        type: 'gauge'
+      });
+
+      // Error rate
+      const errorRate = perfData.max_errors_rate?.actual || perfData.error_rate || 0;
+      metrics.push({
+        name: 'qa360_perf_error_rate',
+        value: errorRate,
+        help: 'Performance error rate',
+        type: 'gauge'
+      });
+
+    } catch {
+      // Return empty metrics on error
+    }
+
+    return metrics;
+  }
+
+  private async getLastRunData(): Promise<any> {
+    try {
+      const runsDir = join(process.cwd(), '.qa360', 'runs');
+      if (!existsSync(runsDir)) return null;
+
+      const fs = require('fs');
+      const runFiles = fs.readdirSync(runsDir)
+        .filter((f: string) => f.endsWith('.json'))
+        .sort();
+      
+      if (runFiles.length === 0) return null;
+
+      const lastRunFile = runFiles.pop();
+      const lastRunPath = join(runsDir, lastRunFile!);
+      return JSON.parse(fs.readFileSync(lastRunPath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  private formatOpenMetrics(metrics: MetricValue[]): string {
+    const lines: string[] = [];
+    
+    // Group metrics by name for proper formatting
+    const metricGroups = new Map<string, MetricValue[]>();
+    
+    for (const metric of metrics) {
+      if (!metricGroups.has(metric.name)) {
+        metricGroups.set(metric.name, []);
+      }
+      metricGroups.get(metric.name)!.push(metric);
+    }
+
+    // Format each metric group
+    for (const [name, metricList] of metricGroups) {
+      const firstMetric = metricList[0];
+      
+      // Add help comment
+      if (firstMetric.help) {
+        lines.push(`# HELP ${name} ${firstMetric.help}`);
+      }
+      
+      // Add type comment
+      if (firstMetric.type) {
+        lines.push(`# TYPE ${name} ${firstMetric.type}`);
+      }
+      
+      // Add metric lines
+      for (const metric of metricList) {
+        let line = name;
+        
+        if (metric.labels && Object.keys(metric.labels).length > 0) {
+          const labelPairs = Object.entries(metric.labels)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join(',');
+          line += `{${labelPairs}}`;
+        }
+        
+        line += ` ${metric.value}`;
+        lines.push(line);
+      }
+      
+      lines.push(''); // Empty line between metric groups
+    }
+
+    return lines.join('\n');
+  }
+
+  private getVersion(): string {
+    try {
+      const packageInfo = require('../../package.json');
+      return packageInfo.version || '0.9.0-core';
+    } catch {
+      return '0.9.0-core';
+    }
+  }
+}

package/core/src/serve/process-manager.ts

@@ -0,0 +1,265 @@
+/**
+ * QA360 Process Manager
+ * Gestion graceful shutdown et cancel safe des processus
+ */
+
+import { spawn, ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+
+export interface RunProcess {
+  runId: string;
+  pid: number;
+  startTime: number;
+  command: string;
+  status: 'running' | 'cancelled' | 'completed' | 'failed';
+  children: ChildProcess[];
+}
+
+export interface CancelResult {
+  cancelled: boolean;
+  runId: string;
+  reason?: string;
+}
+
+export class ProcessManager extends EventEmitter {
+  private activeRuns = new Map<string, RunProcess>();
+  private gracefulTimeout = 10000; // 10 seconds
+
+  constructor() {
+    super();
+    // Augmenter la limite des listeners pour les tests
+    if (process.env.NODE_ENV === 'test') {
+      process.setMaxListeners(50);
+    }
+    this.setupSignalHandlers();
+  }
+
+  registerRun(runId: string, command: string, mainProcess?: ChildProcess): void {
+    const runProcess: RunProcess = {
+      runId,
+      pid: mainProcess?.pid || process.pid,
+      startTime: Date.now(),
+      command,
+      status: 'running',
+      children: mainProcess ? [mainProcess] : []
+    };
+
+    this.activeRuns.set(runId, runProcess);
+    this.emit('run-registered', runProcess);
+
+    // Auto-cleanup on process exit
+    if (mainProcess) {
+      mainProcess.on('exit', () => {
+        this.completeRun(runId);
+      });
+    }
+  }
+
+  addChildProcess(runId: string, child: ChildProcess): void {
+    const run = this.activeRuns.get(runId);
+    if (run) {
+      run.children.push(child);
+    }
+  }
+
+  async cancelRun(runId: string): Promise<CancelResult> {
+    const run = this.activeRuns.get(runId);
+    
+    if (!run) {
+      return {
+        cancelled: false,
+        runId,
+        reason: 'Run not found'
+      };
+    }
+
+    if (run.status !== 'running') {
+      return {
+        cancelled: false,
+        runId,
+        reason: `Run already ${run.status}`
+      };
+    }
+
+    try {
+      await this.gracefulShutdown(run);
+      run.status = 'cancelled';
+      this.emit('run-cancelled', run);
+      
+      return {
+        cancelled: true,
+        runId
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        cancelled: false,
+        runId,
+        reason: `Failed to cancel: ${errorMessage}`
+      };
+    }
+  }
+
+  async cancelAllRuns(): Promise<CancelResult[]> {
+    const results: CancelResult[] = [];
+    
+    for (const runId of this.activeRuns.keys()) {
+      const result = await this.cancelRun(runId);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  getActiveRuns(): RunProcess[] {
+    return Array.from(this.activeRuns.values());
+  }
+
+  getRunStatus(runId: string): RunProcess | null {
+    return this.activeRuns.get(runId) || null;
+  }
+
+  private async gracefulShutdown(run: RunProcess): Promise<void> {
+    const promises: Promise<void>[] = [];
+
+    // Send SIGTERM to all child processes
+    for (const child of run.children) {
+      if (child.pid && !child.killed) {
+        promises.push(this.terminateProcess(child));
+      }
+    }
+
+    // Wait for all processes to terminate
+    await Promise.all(promises);
+
+    // Clean up Docker containers if any
+    await this.cleanupDockerContainers(run);
+  }
+
+  private async terminateProcess(process: ChildProcess): Promise<void> {
+    return new Promise((resolve) => {
+      if (!process.pid || process.killed) {
+        resolve();
+        return;
+      }
+
+      let terminated = false;
+
+      // Set up exit handler
+      const onExit = () => {
+        if (!terminated) {
+          terminated = true;
+          resolve();
+        }
+      };
+
+      process.on('exit', onExit);
+      process.on('error', onExit);
+
+      // Send SIGTERM
+      try {
+        process.kill('SIGTERM');
+      } catch {
+        // Process might already be dead
+        onExit();
+        return;
+      }
+
+      // Force kill after timeout
+      setTimeout(() => {
+        if (!terminated && process.pid && !process.killed) {
+          try {
+            process.kill('SIGKILL');
+          } catch {
+            // Process might already be dead
+          }
+          onExit();
+        }
+      }, this.gracefulTimeout);
+    });
+  }
+
+  private async cleanupDockerContainers(run: RunProcess): Promise<void> {
+    try {
+      // Check if docker-compose was used
+      if (run.command.includes('docker-compose') || run.command.includes('docker compose')) {
+        const composeDown = spawn('docker', ['compose', 'down'], {
+          stdio: 'pipe',
+          timeout: 30000
+        });
+
+        await new Promise<void>((resolve) => {
+          composeDown.on('exit', () => resolve());
+          composeDown.on('error', () => resolve()); // Continue even if cleanup fails
+          
+          setTimeout(() => {
+            composeDown.kill();
+            resolve();
+          }, 30000);
+        });
+      }
+
+      // Clean up any QA360-related containers
+      const cleanup = spawn('docker', [
+        'ps', '-q', '--filter', 'label=qa360.run-id=' + run.runId
+      ], { stdio: 'pipe' });
+
+      cleanup.stdout.on('data', (data) => {
+        const containerIds = data.toString().trim().split('\n').filter(Boolean);
+        
+        for (const containerId of containerIds) {
+          spawn('docker', ['stop', containerId], { stdio: 'ignore' });
+        }
+      });
+
+    } catch {
+      // Docker cleanup is best effort
+    }
+  }
+
+  private completeRun(runId: string): void {
+    const run = this.activeRuns.get(runId);
+    if (run && run.status === 'running') {
+      run.status = 'completed';
+      this.emit('run-completed', run);
+    }
+  }
+
+  private setupSignalHandlers(): void {
+    const handleShutdown = async (signal: string) => {
+      console.log(`\nReceived ${signal}. Gracefully shutting down...`);
+      
+      try {
+        await this.cancelAllRuns();
+        console.log('All runs cancelled successfully');
+      } catch (error) {
+        console.error('Error during shutdown:', error);
+      }
+      
+      process.exit(0);
+    };
+
+    process.on('SIGINT', () => handleShutdown('SIGINT'));
+    process.on('SIGTERM', () => handleShutdown('SIGTERM'));
+    
+    // Handle uncaught exceptions
+    process.on('uncaughtException', async (error) => {
+      console.error('Uncaught exception:', error);
+      await this.cancelAllRuns();
+      process.exit(1);
+    });
+
+    process.on('unhandledRejection', async (reason) => {
+      console.error('Unhandled rejection:', reason);
+      await this.cancelAllRuns();
+      process.exit(1);
+    });
+  }
+
+  dispose() {
+    process.removeAllListeners('SIGINT');
+    process.removeAllListeners('SIGTERM');
+    process.removeAllListeners('uncaughtException');
+    process.removeAllListeners('unhandledRejection');
+  }
+}