@testsmith/perfornium 0.2.0 → 0.4.0

package/dist/core/test-runner.js

@@ -52,6 +52,7 @@ const time_1 = require("../utils/time");
 const csv_data_provider_1 = require("./csv-data-provider");
 const rendezvous_1 = require("./rendezvous");
 const file_manager_1 = require("../utils/file-manager");
+const dashboard_1 = require("../dashboard");
 class TestRunner {
     constructor(config) {
         this.handlers = new Map();
@@ -59,6 +60,9 @@ class TestRunner {
         this.activeVUs = [];
         this.isRunning = false;
         this.startTime = 0;
+        this.testId = '';
+        this.dashboardInterval = null;
+        this.lastReportedResultIndex = 0;
         this.config = config;
         this.metrics = new collector_1.MetricsCollector();
         // Set log level based on debug config
@@ -84,8 +88,11 @@ class TestRunner {
         logger_1.logger.info(`🚀 Starting test: ${this.config.name}`);
         this.isRunning = true;
         this.startTime = Date.now();
+        this.testId = `test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Reset rendezvous manager for this test run
         rendezvous_1.RendezvousManager.getInstance().reset();
+        // Start dashboard reporting if dashboard is running
+        this.startDashboardReporting();
         try {
             await this.initialize();
             // NO CSV termination callback setup needed anymore
@@ -100,6 +107,113 @@ class TestRunner {
         }
         finally {
             this.isRunning = false;
+            this.stopDashboardReporting();
+        }
+    }
+    startDashboardReporting() {
+        const dashboard = (0, dashboard_1.getDashboard)();
+        // If running standalone (no dashboard singleton), output progress to stdout for dashboard parsing
+        const outputProgress = !dashboard && process.env.PERFORNIUM_PROGRESS !== '0';
+        if (dashboard) {
+            // Report initial state to in-process dashboard
+            dashboard.reportLiveUpdate(this.testId, {
+                id: this.testId,
+                name: this.config.name,
+                startTime: new Date(),
+                status: 'running',
+                metrics: {
+                    requests: 0,
+                    errors: 0,
+                    avgResponseTime: 0,
+                    currentVUs: 0
+                }
+            });
+        }
+        // Track last request count to detect activity
+        let lastRequestCount = 0;
+        // Report updates every 500ms
+        this.dashboardInterval = setInterval(() => {
+            if (!this.isRunning)
+                return;
+            const summary = this.metrics.getSummary();
+            const currentVUs = this.activeVUs.filter(vu => vu.isRunning()).length;
+            const currentRequests = summary.total_requests || 0;
+            // Skip reporting if VUs are 0 and no new requests (test is winding down)
+            const hasActivity = currentVUs > 0 || currentRequests > lastRequestCount;
+            lastRequestCount = currentRequests;
+            if (dashboard) {
+                dashboard.reportLiveUpdate(this.testId, {
+                    metrics: {
+                        requests: currentRequests,
+                        errors: summary.failed_requests || 0,
+                        avgResponseTime: summary.avg_response_time || 0,
+                        currentVUs
+                    }
+                });
+            }
+            // Output machine-readable progress for dashboard parsing (only when there's activity)
+            if (outputProgress && hasActivity) {
+                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;
+                // Main progress line with percentiles
+                console.log(`[PROGRESS] VUs: ${currentVUs} | 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)}%`);
+                // 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 (last 50 new results)
+                const allResults = this.metrics.getResults();
+                if (allResults.length > this.lastReportedResultIndex) {
+                    const newResults = allResults.slice(this.lastReportedResultIndex, this.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)}`);
+                    }
+                    this.lastReportedResultIndex = Math.min(allResults.length, this.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),
+                        url: e.request_url,
+                        count: e.count
+                    }));
+                    console.log(`[ERRORS] ${JSON.stringify(topErrors)}`);
+                }
+            }
+        }, 500);
+    }
+    stopDashboardReporting() {
+        if (this.dashboardInterval) {
+            clearInterval(this.dashboardInterval);
+            this.dashboardInterval = null;
+        }
+        const dashboard = (0, dashboard_1.getDashboard)();
+        if (dashboard) {
+            dashboard.reportTestComplete(this.testId);
         }
     }
     setupCSVBaseDirectory() {
@@ -356,19 +470,24 @@ class TestRunner {
     }
     async waitForVUsToComplete(timeoutMs = 60000) {
         const startTime = Date.now();
-        while (this.activeVUs.length > 0 && this.isRunning) {
+        // Filter to only running VUs
+        const getRunningVUs = () => this.activeVUs.filter(vu => vu.isRunning());
+        while (getRunningVUs().length > 0 && this.isRunning) {
             const elapsed = Date.now() - startTime;
+            const runningCount = getRunningVUs().length;
             if (elapsed > timeoutMs) {
-                logger_1.logger.warn(`⚠️  Timeout waiting for ${this.activeVUs.length} VUs to complete`);
+                logger_1.logger.warn(`⚠️  Timeout waiting for ${runningCount} VUs to complete`);
                 // Force stop remaining VUs
                 this.activeVUs.forEach(vu => vu.stop());
                 break;
             }
-            await (0, time_1.sleep)(1000);
-            if (this.activeVUs.length > 0 && elapsed % 5000 === 0) { // Log every 5 seconds
-                logger_1.logger.debug(`⏳ Waiting for ${this.activeVUs.length} VUs to complete...`);
+            await (0, time_1.sleep)(100); // Check more frequently
+            if (runningCount > 0 && elapsed % 5000 === 0) { // Log every 5 seconds
+                logger_1.logger.debug(`⏳ Waiting for ${runningCount} VUs to complete...`);
             }
         }
+        // Clear the activeVUs array
+        this.activeVUs.length = 0;
         logger_1.logger.debug('✅ All VUs completed');
     }
     async cleanup() {

package/dist/core/virtual-user.js

@@ -258,9 +258,19 @@ class VirtualUser {
                                 this.metrics.recordResult(result);
                             }
                             // Apply hierarchical think time: step > scenario > global
-                            const effectiveThinkTime = this.getEffectiveThinkTime(step, scenario);
-                            if (effectiveThinkTime !== undefined) {
-                                await this.applyThinkTime(effectiveThinkTime);
+                            // Skip think time if the NEXT step is a verification/wait step - they measure app
+                            // responsiveness and should run immediately after the triggering action
+                            const nextStep = scenario.steps[stepIndex + 1];
+                            const nextCommand = nextStep?.action?.command || '';
+                            const nextIsVerificationOrWait = nextCommand.startsWith('verify_') ||
+                                nextCommand.startsWith('wait_for_') ||
+                                nextCommand === 'measure_web_vitals' ||
+                                nextCommand === 'performance_audit';
+                            if (!nextIsVerificationOrWait) {
+                                const effectiveThinkTime = this.getEffectiveThinkTime(step, scenario);
+                                if (effectiveThinkTime !== undefined) {
+                                    await this.applyThinkTime(effectiveThinkTime);
+                                }
                             }
                         }
                         catch (error) {

package/dist/dashboard/index.d.ts

@@ -0,0 +1 @@
+export { DashboardServer, getDashboard, setDashboard } from './server';

package/dist/dashboard/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDashboard = exports.getDashboard = exports.DashboardServer = void 0;
+var server_1 = require("./server");
+Object.defineProperty(exports, "DashboardServer", { enumerable: true, get: function () { return server_1.DashboardServer; } });
+Object.defineProperty(exports, "getDashboard", { enumerable: true, get: function () { return server_1.getDashboard; } });
+Object.defineProperty(exports, "setDashboard", { enumerable: true, get: function () { return server_1.setDashboard; } });

package/dist/dashboard/server.d.ts

@@ -0,0 +1,100 @@
+interface DashboardOptions {
+    port: number;
+    resultsDir: string;
+    testsDir?: string;
+    workersFile?: string;
+}
+interface LiveTest {
+    id: string;
+    name: string;
+    startTime: Date;
+    status: 'running' | 'completed' | 'failed';
+    metrics: {
+        requests: number;
+        errors: number;
+        avgResponseTime: number;
+        currentVUs: number;
+        p50ResponseTime?: number;
+        p90ResponseTime?: number;
+        p95ResponseTime?: number;
+        p99ResponseTime?: number;
+        minResponseTime?: number;
+        maxResponseTime?: number;
+        requestsPerSecond?: number;
+        successRate?: number;
+    };
+    stepStats: {
+        stepName: string;
+        scenario: string;
+        requests: number;
+        errors: number;
+        avgResponseTime: number;
+        p50?: number;
+        p95?: number;
+        p99?: number;
+        successRate: number;
+    }[];
+    responseTimes: {
+        timestamp: number;
+        value: number;
+        success: boolean;
+        stepName?: string;
+    }[];
+    topErrors: {
+        scenario: string;
+        action: string;
+        status?: number;
+        error: string;
+        url?: string;
+        count: number;
+    }[];
+    history: {
+        timestamp: number;
+        requests: number;
+        errors: number;
+        avgResponseTime: number;
+        p95ResponseTime: number;
+        p99ResponseTime: number;
+        vus: number;
+        rps: number;
+    }[];
+}
+export declare class DashboardServer {
+    private server;
+    private wss;
+    private options;
+    private clients;
+    private liveTests;
+    private runningProcesses;
+    constructor(options: DashboardOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reportLiveUpdate(testId: string, update: Partial<LiveTest>): void;
+    reportTestComplete(testId: string): void;
+    private broadcast;
+    private handleRequest;
+    private handleGetResults;
+    private handleGetResult;
+    private handleDeleteResult;
+    private handleCompare;
+    private handleGetLive;
+    private handleGetTests;
+    private handleGetWorkers;
+    private handleRunTest;
+    private parseOutputForMetrics;
+    private handleStopTest;
+    private readBody;
+    private scanTestFiles;
+    private scanDirForTests;
+    private scanResults;
+    private extractSummary;
+    private loadFullResult;
+    private generateComparison;
+    private generateStepComparisons;
+    private calcDiff;
+    private serveStatic;
+    private getDashboardHTML;
+}
+export declare function getDashboard(): DashboardServer | null;
+export declare function setDashboard(dashboard: DashboardServer): void;
+export {};