qa360 2.2.1 → 2.2.13

package/cli/dist/core/serve/metrics-collector.js

@@ -0,0 +1,322 @@
+/**
+ * QA360 Metrics Collector
+ * Génère des métriques au format OpenMetrics/Prometheus
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+export class MetricsCollector {
+    startTime;
+    constructor() {
+        this.startTime = Date.now();
+    }
+    async collect() {
+        const metrics = await this.gatherMetrics();
+        return this.formatOpenMetrics(metrics);
+    }
+    async gatherMetrics() {
+        const metrics = [];
+        // 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;
+    }
+    async collectRunMetrics() {
+        const metrics = [];
+        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) => 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;
+    }
+    async collectGateMetrics() {
+        const metrics = [];
+        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;
+    }
+    async collectSecurityMetrics() {
+        const metrics = [];
+        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;
+    }
+    async collectPerformanceMetrics() {
+        const metrics = [];
+        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;
+    }
+    async getLastRunData() {
+        try {
+            const runsDir = join(process.cwd(), '.qa360', 'runs');
+            if (!existsSync(runsDir))
+                return null;
+            const fs = require('fs');
+            const runFiles = fs.readdirSync(runsDir)
+                .filter((f) => 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;
+        }
+    }
+    formatOpenMetrics(metrics) {
+        const lines = [];
+        // Group metrics by name for proper formatting
+        const metricGroups = new Map();
+        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');
+    }
+    getVersion() {
+        try {
+            const packageInfo = require('../../package.json');
+            return packageInfo.version || '0.9.0-core';
+        }
+        catch {
+            return '0.9.0-core';
+        }
+    }
+}

package/cli/dist/core/serve/process-manager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * QA360 Process Manager
+ * Gestion graceful shutdown et cancel safe des processus
+ */
+import { 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 declare class ProcessManager extends EventEmitter {
+    private activeRuns;
+    private gracefulTimeout;
+    constructor();
+    registerRun(runId: string, command: string, mainProcess?: ChildProcess): void;
+    addChildProcess(runId: string, child: ChildProcess): void;
+    cancelRun(runId: string): Promise<CancelResult>;
+    cancelAllRuns(): Promise<CancelResult[]>;
+    getActiveRuns(): RunProcess[];
+    getRunStatus(runId: string): RunProcess | null;
+    private gracefulShutdown;
+    private terminateProcess;
+    private cleanupDockerContainers;
+    private completeRun;
+    private setupSignalHandlers;
+    dispose(): void;
+}

package/cli/dist/core/serve/process-manager.js

@@ -0,0 +1,213 @@
+/**
+ * QA360 Process Manager
+ * Gestion graceful shutdown et cancel safe des processus
+ */
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+export class ProcessManager extends EventEmitter {
+    activeRuns = new Map();
+    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, command, mainProcess) {
+        const 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, child) {
+        const run = this.activeRuns.get(runId);
+        if (run) {
+            run.children.push(child);
+        }
+    }
+    async cancelRun(runId) {
+        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() {
+        const results = [];
+        for (const runId of this.activeRuns.keys()) {
+            const result = await this.cancelRun(runId);
+            results.push(result);
+        }
+        return results;
+    }
+    getActiveRuns() {
+        return Array.from(this.activeRuns.values());
+    }
+    getRunStatus(runId) {
+        return this.activeRuns.get(runId) || null;
+    }
+    async gracefulShutdown(run) {
+        const promises = [];
+        // 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);
+    }
+    async terminateProcess(process) {
+        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);
+        });
+    }
+    async cleanupDockerContainers(run) {
+        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((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
+        }
+    }
+    completeRun(runId) {
+        const run = this.activeRuns.get(runId);
+        if (run && run.status === 'running') {
+            run.status = 'completed';
+            this.emit('run-completed', run);
+        }
+    }
+    setupSignalHandlers() {
+        const handleShutdown = async (signal) => {
+            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');
+    }
+}

package/cli/dist/core/serve/server.d.ts

@@ -0,0 +1,36 @@
+/**
+ * QA360 Core Observability Server
+ * Endpoints: /health, /diag, /metrics, /cancel
+ */
+export interface ServeConfig {
+    port: number;
+    host?: string;
+    metrics?: boolean;
+    readinessCheck?: boolean;
+    verbose?: boolean;
+}
+export interface ServeResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}
+export declare class QA360Server {
+    private config;
+    private server?;
+    private healthChecker;
+    private diagnosticsCollector;
+    private metricsCollector;
+    private processManager;
+    private redactor;
+    private startTime;
+    constructor(config: ServeConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private routeRequest;
+    private handleHealth;
+    private handleDiagnostics;
+    private handleMetrics;
+    private handleCancel;
+    private log;
+}