qa360 2.1.2 → 2.1.4

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

@@ -1,322 +0,0 @@
-/**
- * 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/dist/core/serve/process-manager.d.ts

@@ -1,36 +0,0 @@
-/**
- * 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/dist/core/serve/process-manager.js

@@ -1,213 +0,0 @@
-/**
- * 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/dist/core/serve/server.d.ts

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