@testsmith/perfornium 0.2.0 → 0.4.0

package/dist/cli/cli.js

@@ -8,6 +8,7 @@ const report_1 = require("./commands/report");
 const worker_1 = require("./commands/worker");
 const init_1 = require("./commands/init");
 const mock_1 = require("./commands/mock");
+const dashboard_1 = require("./commands/dashboard");
 const native_recorder_1 = require("../recorder/native-recorder");
 const distributed_1 = require("./commands/distributed");
 // Add new import commands
@@ -31,6 +32,10 @@ program
     .option('-v, --verbose', 'Enable verbose logging (info level)')
     .option('-d, --debug', 'Enable debug logging (very detailed)')
     .option('--max-users <number>', 'Maximum virtual users override')
+    .option('--vus <number>', 'Override virtual users count')
+    .option('--iterations <number>', 'Override iterations per VU')
+    .option('--duration <duration>', 'Override test duration (e.g., 30s, 1m, 5m)')
+    .option('--ramp-up <duration>', 'Override ramp-up time (e.g., 10s, 1m)')
     .option('-g, --global <key=value>', 'Override global config (supports dot notation: browser.headless=false)', collectGlobals, [])
     .action(run_1.runCommand);
 // Helper function to collect --global options
@@ -189,4 +194,13 @@ program
     .option('--host <host>', 'Host to bind to', 'localhost')
     .option('-d, --delay <ms>', 'Add delay to all responses (ms)', '0')
     .action(mock_1.mockCommand);
+program
+    .command('dashboard')
+    .description('Start the dashboard web UI to view and compare test results')
+    .option('-p, --port <port>', 'Port to listen on', '3000')
+    .option('-r, --results <directory>', 'Results directory to scan', './results')
+    .option('-t, --tests <directory>', 'Tests directory (defaults to parent of results)')
+    .option('-w, --workers <file>', 'Workers configuration file (JSON) for distributed testing')
+    .option('--no-open', 'Do not open browser automatically')
+    .action(dashboard_1.dashboardCommand);
 program.parse();

package/dist/cli/commands/dashboard.d.ts

@@ -0,0 +1,9 @@
+interface DashboardOptions {
+    port: string;
+    results: string;
+    tests?: string;
+    workers?: string;
+    open?: boolean;
+}
+export declare function dashboardCommand(options: DashboardOptions): Promise<void>;
+export {};

package/dist/cli/commands/dashboard.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardCommand = dashboardCommand;
+const dashboard_1 = require("../../dashboard");
+const logger_1 = require("../../utils/logger");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+async function dashboardCommand(options) {
+    const port = parseInt(options.port, 10);
+    const resultsDir = path.resolve(options.results);
+    // Default testsDir to parent of results directory (common structure: project/results, project/tests)
+    const testsDir = options.tests ? path.resolve(options.tests) : path.resolve(resultsDir, '..');
+    const workersFile = options.workers ? path.resolve(options.workers) : undefined;
+    console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                   Perfornium Dashboard                        ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Results directory: ${resultsDir.padEnd(40)} ║
+║  Tests directory:   ${testsDir.padEnd(40)} ║
+${workersFile ? `║  Workers file:      ${workersFile.padEnd(40)} ║\n` : ''}║  Dashboard URL:     http://localhost:${port.toString().padEnd(26)} ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+    const dashboard = new dashboard_1.DashboardServer({
+        port,
+        resultsDir,
+        testsDir,
+        workersFile
+    });
+    // Store dashboard instance globally for test runner integration
+    (0, dashboard_1.setDashboard)(dashboard);
+    await dashboard.start();
+    // Open browser if not disabled
+    if (options.open !== false) {
+        const url = `http://localhost:${port}`;
+        const platform = process.platform;
+        let command;
+        if (platform === 'darwin') {
+            command = `open "${url}"`;
+        }
+        else if (platform === 'win32') {
+            command = `start "${url}"`;
+        }
+        else {
+            command = `xdg-open "${url}"`;
+        }
+        (0, child_process_1.exec)(command, (error) => {
+            if (error) {
+                logger_1.logger.debug('Could not open browser automatically:', error.message);
+            }
+        });
+    }
+    console.log('Press Ctrl+C to stop the dashboard\n');
+    // Keep running until interrupted
+    process.on('SIGINT', async () => {
+        console.log('\nShutting down dashboard...');
+        await dashboard.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await dashboard.stop();
+        process.exit(0);
+    });
+    // Keep the process alive
+    await new Promise(() => { });
+}

package/dist/cli/commands/run.d.ts

@@ -7,6 +7,10 @@ export interface RunOptions {
     verbose?: boolean;
     debug?: boolean;
     maxUsers?: string;
+    vus?: string;
+    iterations?: string;
+    duration?: string;
+    rampUp?: string;
     global?: string[];
 }
 export declare function runCommand(configPath: string, options: RunOptions): Promise<void>;

package/dist/cli/commands/run.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
 const path = __importStar(require("path"));
 const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
 const parser_1 = require("../../config/parser");
 const validator_1 = require("../../config/validator");
 const test_runner_1 = require("../../core/test-runner");
@@ -104,15 +105,44 @@ async function runCommand(configPath, options) {
         if (baseUrl.match(/^https?:\/\/localhost:3000/)) {
             await startMockServer(3000);
         }
-        // Apply max users override
-        if (options.maxUsers) {
-            const maxUsers = parseInt(options.maxUsers);
+        // Apply load pattern overrides
+        if (options.maxUsers || options.vus || options.iterations || options.duration || options.rampUp) {
             const { getPrimaryLoadPhase } = await Promise.resolve().then(() => __importStar(require('../../config/types/load-config')));
             const primaryPhase = getPrimaryLoadPhase(config.load);
-            const currentUsers = primaryPhase.virtual_users || primaryPhase.vus;
-            if (currentUsers && currentUsers > maxUsers) {
-                logger_1.logger.warn(`Limiting virtual users from ${currentUsers} to ${maxUsers}`);
-                primaryPhase.virtual_users = maxUsers;
+            // Virtual users override
+            if (options.vus) {
+                const vus = parseInt(options.vus);
+                logger_1.logger.info(`Overriding virtual users to ${vus}`);
+                primaryPhase.virtual_users = vus;
+                if (primaryPhase.vus)
+                    primaryPhase.vus = vus;
+            }
+            // Max users override (limit, not set)
+            if (options.maxUsers) {
+                const maxUsers = parseInt(options.maxUsers);
+                const currentUsers = primaryPhase.virtual_users || primaryPhase.vus;
+                if (currentUsers && currentUsers > maxUsers) {
+                    logger_1.logger.warn(`Limiting virtual users from ${currentUsers} to ${maxUsers}`);
+                    primaryPhase.virtual_users = maxUsers;
+                }
+            }
+            // Iterations override
+            if (options.iterations) {
+                const iterations = parseInt(options.iterations);
+                logger_1.logger.info(`Overriding iterations to ${iterations}`);
+                primaryPhase.iterations = iterations;
+            }
+            // Duration override
+            if (options.duration) {
+                logger_1.logger.info(`Overriding duration to ${options.duration}`);
+                primaryPhase.duration = options.duration;
+                // Remove iterations if duration is set (they're mutually exclusive)
+                delete primaryPhase.iterations;
+            }
+            // Ramp-up override
+            if (options.rampUp) {
+                logger_1.logger.info(`Overriding ramp-up to ${options.rampUp}`);
+                primaryPhase.ramp_up = options.rampUp;
             }
         }
         // Process templates with environment variables
@@ -138,12 +168,29 @@ async function runCommand(configPath, options) {
             return;
         }
         // Override output directory if specified
-        if (options.output && processedConfig.outputs) {
-            processedConfig.outputs.forEach(output => {
-                if (output.file) {
-                    output.file = path.join(options.output, path.basename(output.file));
-                }
-            });
+        if (options.output) {
+            // Ensure output directory exists
+            if (!fs.existsSync(options.output)) {
+                fs.mkdirSync(options.output, { recursive: true });
+            }
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').substring(0, 19);
+            const testName = processedConfig.name || path.basename(configPath, path.extname(configPath));
+            const defaultOutputFile = path.join(options.output, `${testName}-${timestamp}.json`);
+            if (processedConfig.outputs && processedConfig.outputs.length > 0) {
+                // Modify existing outputs to use the specified directory
+                processedConfig.outputs.forEach(output => {
+                    if (output.file) {
+                        output.file = path.join(options.output, path.basename(output.file));
+                    }
+                });
+            }
+            else {
+                // No outputs configured - add default JSON output
+                processedConfig.outputs = [{
+                        type: 'json',
+                        file: defaultOutputFile
+                    }];
+            }
         }
         // Enable report generation if requested
         if (options.report) {
@@ -160,12 +207,94 @@ async function runCommand(configPath, options) {
             for (const address of workerAddresses) {
                 await manager.addWorker(address);
             }
+            // Initialize metrics before distributing test
+            const metrics = manager.getAggregatedMetrics();
+            metrics.start();
+            // Track results as they come in
+            let resultCount = 0;
+            manager.on('result', () => {
+                resultCount++;
+            });
             await manager.distributeTest(processedConfig);
+            logger_1.logger.info('📡 Test distributed to workers, starting progress reporting...');
+            // Start live progress reporting for dashboard
+            let lastReportedResultIndex = 0;
+            let isRunning = true;
+            // Output function for progress reporting
+            const outputProgress = () => {
+                if (!isRunning)
+                    return;
+                const summary = metrics.getSummary();
+                const currentRequests = summary.total_requests || 0;
+                const rps = summary.requests_per_second || 0;
+                const p50 = summary.percentiles?.[50] || 0;
+                const p90 = summary.percentiles?.[90] || 0;
+                const p95 = summary.percentiles?.[95] || 0;
+                const p99 = summary.percentiles?.[99] || 0;
+                const successRate = summary.success_rate || 0;
+                // Output progress line for dashboard parsing
+                const progressLine = `[PROGRESS] VUs: ${manager.getWorkerCount()} | Requests: ${currentRequests} | Errors: ${summary.failed_requests || 0} | Avg RT: ${(summary.avg_response_time || 0).toFixed(0)}ms | RPS: ${rps.toFixed(1)} | P50: ${p50.toFixed(0)}ms | P90: ${p90.toFixed(0)}ms | P95: ${p95.toFixed(0)}ms | P99: ${p99.toFixed(0)}ms | Success: ${successRate.toFixed(1)}%`;
+                console.log(progressLine);
+                // Output step statistics if available
+                if (summary.step_statistics && summary.step_statistics.length > 0) {
+                    const stepData = summary.step_statistics.map((s) => ({
+                        n: s.step_name,
+                        s: s.scenario,
+                        r: s.total_requests,
+                        e: s.failed_requests,
+                        a: Math.round(s.avg_response_time),
+                        p50: Math.round(s.percentiles?.[50] || 0),
+                        p95: Math.round(s.percentiles?.[95] || 0),
+                        p99: Math.round(s.percentiles?.[99] || 0),
+                        sr: Math.round(s.success_rate * 10) / 10
+                    }));
+                    console.log(`[STEPS] ${JSON.stringify(stepData)}`);
+                }
+                // Output individual response times for charts
+                const allResults = metrics.getResults();
+                if (allResults.length > lastReportedResultIndex) {
+                    const newResults = allResults.slice(lastReportedResultIndex, lastReportedResultIndex + 50);
+                    const rtData = newResults.map((r) => ({
+                        t: r.timestamp,
+                        v: Math.round(r.duration),
+                        s: r.success ? 1 : 0,
+                        n: r.step_name || r.action || 'unknown' // Include step/request name for coloring
+                    }));
+                    if (rtData.length > 0) {
+                        console.log(`[RT] ${JSON.stringify(rtData)}`);
+                    }
+                    lastReportedResultIndex = Math.min(allResults.length, lastReportedResultIndex + 50);
+                }
+                // Output top 10 errors if any
+                if (summary.error_details && summary.error_details.length > 0) {
+                    const topErrors = summary.error_details.slice(0, 10).map((e) => ({
+                        scenario: e.scenario,
+                        action: e.action,
+                        status: e.status,
+                        error: e.error?.substring(0, 200), // Truncate long error messages
+                        url: e.request_url,
+                        count: e.count
+                    }));
+                    console.log(`[ERRORS] ${JSON.stringify(topErrors)}`);
+                }
+            };
+            // Output initial progress immediately
+            outputProgress();
+            // Then continue outputting every 500ms
+            const progressInterval = setInterval(outputProgress, 500);
             await manager.waitForCompletion();
-            const metrics = manager.getAggregatedMetrics();
+            logger_1.logger.info('✅ All workers completed, cleaning up...');
+            // Stop progress reporting
+            isRunning = false;
+            clearInterval(progressInterval);
             const summary = metrics.getSummary();
             logger_1.logger.success(`Distributed test completed: ${summary.success_rate.toFixed(2)}% success rate`);
+            logger_1.logger.info(`📊 Total requests: ${summary.total_requests}, Success rate: ${summary.success_rate.toFixed(1)}%`);
+            logger_1.logger.info('🧹 Starting cleanup...');
             await manager.cleanup();
+            logger_1.logger.info('✅ Cleanup completed, exiting...');
+            // Force exit after distributed test cleanup to ensure process terminates
+            process.exit(0);
         }
         else {
             const runner = new test_runner_1.TestRunner(processedConfig);

package/dist/cli/commands/worker.d.ts

@@ -1,12 +1,20 @@
 export declare class WorkerServer {
     private server;
+    private wss;
     private host;
     private port;
     private status;
     private activeRunner;
     private preparedConfig;
     private completedRunner;
+    private wsClients;
     constructor(host?: string, port?: number);
+    private setupWebSocketHandlers;
+    private handleWebSocketMessage;
+    private executeWsTest;
+    private stopWsTest;
+    private sendWsMessage;
+    private sendWsError;
     private handleRequest;
     private handleHealth;
     private handleStatus;

package/dist/cli/commands/worker.js

@@ -38,12 +38,14 @@ exports.workerCommand = workerCommand;
 const logger_1 = require("../../utils/logger");
 const http = __importStar(require("http"));
 const url_1 = require("url");
+const ws_1 = require("ws");
 const test_runner_1 = require("../../core/test-runner");
 class WorkerServer {
     constructor(host = 'localhost', port = 8080) {
         this.activeRunner = null;
         this.preparedConfig = null;
         this.completedRunner = null;
+        this.wsClients = new Map();
         this.host = host;
         this.port = port;
         this.status = {
@@ -57,6 +59,129 @@ class WorkerServer {
         this.server = http.createServer((req, res) => {
             this.handleRequest(req, res);
         });
+        // WebSocket server for distributed testing
+        this.wss = new ws_1.WebSocketServer({
+            server: this.server,
+            path: '/perfornium'
+        });
+        this.setupWebSocketHandlers();
+    }
+    setupWebSocketHandlers() {
+        this.wss.on('connection', (ws, req) => {
+            const clientIP = req.socket.remoteAddress;
+            logger_1.logger.info(`🔌 WebSocket client connected from ${clientIP}`);
+            this.wsClients.set(ws, null);
+            ws.on('message', async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    await this.handleWebSocketMessage(ws, message);
+                }
+                catch (error) {
+                    logger_1.logger.error('❌ Error handling WebSocket message:', error);
+                    this.sendWsError(ws, error.message);
+                }
+            });
+            ws.on('close', () => {
+                logger_1.logger.info('👋 WebSocket client disconnected');
+                const runner = this.wsClients.get(ws);
+                if (runner) {
+                    runner.stop().catch(err => logger_1.logger.error('❌ Error stopping runner on disconnect:', err));
+                }
+                this.wsClients.delete(ws);
+            });
+            ws.on('error', (error) => {
+                logger_1.logger.error('❌ WebSocket error:', error);
+                this.wsClients.delete(ws);
+            });
+            // Send heartbeat
+            this.sendWsMessage(ws, { type: 'heartbeat' });
+        });
+    }
+    async handleWebSocketMessage(ws, message) {
+        switch (message.type) {
+            case 'execute_test':
+                await this.executeWsTest(ws, message.config);
+                break;
+            case 'stop_test':
+                await this.stopWsTest(ws);
+                break;
+            case 'heartbeat_ack':
+                // Client is alive
+                break;
+            default:
+                logger_1.logger.warn(`⚠️ Unknown WebSocket message type: ${message.type}`);
+        }
+    }
+    async executeWsTest(ws, config) {
+        try {
+            // Stop any existing test for this connection
+            await this.stopWsTest(ws);
+            const runner = new test_runner_1.TestRunner(config);
+            this.wsClients.set(ws, runner);
+            logger_1.logger.info(`🚀 Starting test via WebSocket: ${config.name}`);
+            const metrics = runner.getMetrics();
+            // Listen for individual results
+            metrics.on('result', (result) => {
+                this.sendWsMessage(ws, {
+                    type: 'test_result',
+                    data: result
+                });
+            });
+            // Send progress updates on batch events
+            metrics.on('batch', (batch) => {
+                this.sendWsMessage(ws, {
+                    type: 'test_progress',
+                    data: {
+                        completed: batch.batch_number * batch.batch_size,
+                        total: batch.batch_size
+                    }
+                });
+            });
+            // Log test start
+            this.sendWsMessage(ws, {
+                type: 'log',
+                message: `Starting test: ${config.name}`
+            });
+            // Start the test
+            runner.run().then(() => {
+                const summary = metrics.getSummary();
+                this.sendWsMessage(ws, {
+                    type: 'test_completed',
+                    summary: summary
+                });
+                this.wsClients.set(ws, null);
+                logger_1.logger.info(`✅ Test completed via WebSocket: ${config.name}`);
+            }).catch((error) => {
+                this.sendWsMessage(ws, {
+                    type: 'test_error',
+                    error: error.message
+                });
+                this.wsClients.set(ws, null);
+                logger_1.logger.error(`❌ Test failed via WebSocket: ${error.message}`);
+            });
+        }
+        catch (error) {
+            this.sendWsMessage(ws, {
+                type: 'test_error',
+                error: error.message
+            });
+        }
+    }
+    async stopWsTest(ws) {
+        const runner = this.wsClients.get(ws);
+        if (runner) {
+            await runner.stop();
+            this.wsClients.set(ws, null);
+            this.sendWsMessage(ws, { type: 'test_stopped' });
+        }
+    }
+    sendWsMessage(ws, message) {
+        if (ws.readyState === ws_1.WebSocket.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    sendWsError(ws, error) {
+        this.sendWsMessage(ws, { type: 'error', error });
     }
     async handleRequest(req, res) {
         // Set CORS headers
@@ -261,6 +386,7 @@ class WorkerServer {
             this.server.listen(this.port, this.host, () => {
                 logger_1.logger.info(`🚀 Worker server started on ${this.host}:${this.port}`);
                 logger_1.logger.info(`📋 Available endpoints:`);
+                logger_1.logger.info(`   WS   ws://${this.host}:${this.port}/perfornium (distributed testing)`);
                 logger_1.logger.info(`   GET  http://${this.host}:${this.port}/health`);
                 logger_1.logger.info(`   GET  http://${this.host}:${this.port}/status`);
                 logger_1.logger.info(`   POST http://${this.host}:${this.port}/prepare`);

package/dist/config/types/global-config.d.ts

@@ -71,4 +71,9 @@ export interface DebugConfig {
     max_response_body_size?: number;
     capture_only_failures?: boolean;
     log_level?: 'debug' | 'info' | 'warn' | 'error';
+    log_requests?: boolean;
+    log_responses?: boolean;
+    log_headers?: boolean;
+    log_body?: boolean;
+    log_timings?: boolean;
 }

package/dist/config/types/load-config.d.ts

@@ -14,7 +14,8 @@ export interface LoadPhase {
     vus?: number;
     virtual_users?: number;
     ramp_up?: string;
-    duration: string;
+    duration?: string;
+    iterations?: number;
     steps?: LoadStep[];
     rate?: number;
 }

package/dist/core/test-runner.d.ts

@@ -8,8 +8,13 @@ export declare class TestRunner {
     private activeVUs;
     private isRunning;
     private startTime;
+    private testId;
+    private dashboardInterval;
     constructor(config: TestConfiguration);
     run(): Promise<void>;
+    private lastReportedResultIndex;
+    private startDashboardReporting;
+    private stopDashboardReporting;
     private setupCSVBaseDirectory;
     stop(): Promise<void>;
     private initialize;