@testsmith/perfornium 0.2.0 → 0.4.0

package/dist/metrics/collector.d.ts

@@ -32,6 +32,9 @@ export declare class MetricsCollector extends EventEmitter {
     private errorDetails;
     private vuStartEvents;
     private loadPatternType;
+    private runningStats;
+    private readonly maxDurationsForPercentiles;
+    private readonly maxStoredResults;
     private realtimeConfig;
     private batchBuffer;
     private batchTimer;

package/dist/metrics/collector.js

@@ -11,6 +11,18 @@ class MetricsCollector extends events_1.EventEmitter {
         this.errorDetails = new Map();
         this.vuStartEvents = [];
         this.loadPatternType = 'basic';
+        // Running statistics (accurate even when individual results are dropped)
+        this.runningStats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalDuration: 0, // Sum of all durations for averaging
+            minDuration: Infinity,
+            maxDuration: 0,
+            durations: [], // For percentile calculation (limited size)
+        };
+        this.maxDurationsForPercentiles = 10000; // Keep last N for percentiles
+        this.maxStoredResults = 50000; // Max individual results to keep in memory
         this.batchBuffer = [];
         this.batchTimer = null;
         this.batchCounter = 0;
@@ -95,6 +107,16 @@ class MetricsCollector extends events_1.EventEmitter {
         this.batchBuffer = [];
         this.batchCounter = 0;
         this.csvHeaderWritten = false;
+        // Reset running statistics
+        this.runningStats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalDuration: 0,
+            minDuration: Infinity,
+            maxDuration: 0,
+            durations: [],
+        };
         if (this.realtimeConfig.enabled && this.realtimeConfig.interval_ms) {
             this.startBatchTimer();
         }
@@ -107,14 +129,44 @@ class MetricsCollector extends events_1.EventEmitter {
         });
     }
     recordResult(result) {
-        this.results.push(result);
+        // Update running statistics (always accurate regardless of stored results)
+        this.runningStats.totalRequests++;
+        if (result.success) {
+            this.runningStats.successfulRequests++;
+            const duration = result.duration || 0;
+            this.runningStats.totalDuration += duration;
+            this.runningStats.minDuration = Math.min(this.runningStats.minDuration, duration);
+            this.runningStats.maxDuration = Math.max(this.runningStats.maxDuration, duration);
+            // Keep limited durations for percentile calculation (reservoir sampling)
+            if (this.runningStats.durations.length < this.maxDurationsForPercentiles) {
+                this.runningStats.durations.push(duration);
+            }
+            else {
+                // Randomly replace an existing duration (reservoir sampling)
+                const replaceIndex = Math.floor(Math.random() * this.runningStats.totalRequests);
+                if (replaceIndex < this.maxDurationsForPercentiles) {
+                    this.runningStats.durations[replaceIndex] = duration;
+                }
+            }
+        }
+        else {
+            this.runningStats.failedRequests++;
+        }
+        // Store result only if under limit (for detailed analysis)
+        if (this.results.length < this.maxStoredResults) {
+            this.results.push(result);
+        }
         this.emit('result', result);
         // Track detailed error information
         if (!result.success) {
             this.trackErrorDetail(result);
         }
-        // Add to batch buffer for real-time processing
+        // Add to batch buffer for real-time processing (with safety limit)
         if (this.realtimeConfig.enabled) {
+            // Safety limit: if buffer exceeds 1000 items, force flush to prevent memory issues
+            if (this.batchBuffer.length >= 1000) {
+                this.flushBatch();
+            }
             this.batchBuffer.push(result);
             // Check if we should flush based on batch size (if not using intervals)
             if (!this.realtimeConfig.interval_ms) {
@@ -509,21 +561,25 @@ class MetricsCollector extends events_1.EventEmitter {
     getResults() {
         return [...this.results];
     }
-    // Add method to configure output paths without recreating the collector
-    // Add method to disable incremental files if needed
     getSummary() {
-        const totalRequests = this.results.length;
-        const successfulRequests = this.results.filter(r => r.success).length;
-        const failedRequests = totalRequests - successfulRequests;
-        const durations = this.results.filter(r => r.success).map(r => r.duration);
+        // Use running statistics for accurate totals (even when individual results are limited)
+        const totalRequests = this.runningStats.totalRequests;
+        const successfulRequests = this.runningStats.successfulRequests;
+        const failedRequests = this.runningStats.failedRequests;
+        // Use sampled durations for percentiles (reservoir sampling ensures representative sample)
+        const durations = this.runningStats.durations;
         const totalDuration = (Date.now() - this.startTime) / 1000;
-        // Error distribution by error message
+        // Calculate average from running totals (accurate even with limited stored results)
+        const avgResponseTime = successfulRequests > 0
+            ? this.runningStats.totalDuration / successfulRequests
+            : 0;
+        // Error distribution from stored results (may be limited but representative)
         const errorDistribution = {};
         this.results.filter(r => !r.success).forEach(r => {
             const error = r.error || 'Unknown error';
             errorDistribution[error] = (errorDistribution[error] || 0) + 1;
         });
-        // Status code distribution
+        // Status code distribution from stored results
         const statusDistribution = {};
         this.results.forEach(r => {
             if (r.status) {
@@ -538,9 +594,9 @@ class MetricsCollector extends events_1.EventEmitter {
             successful_requests: successfulRequests,
             failed_requests: failedRequests,
             success_rate: totalRequests > 0 ? (successfulRequests / totalRequests) * 100 : 0,
-            avg_response_time: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
-            min_response_time: durations.length > 0 ? Math.min(...durations) : 0,
-            max_response_time: durations.length > 0 ? Math.max(...durations) : 0,
+            avg_response_time: avgResponseTime,
+            min_response_time: this.runningStats.minDuration === Infinity ? 0 : this.runningStats.minDuration,
+            max_response_time: this.runningStats.maxDuration,
             percentiles: this.calculatePercentiles(durations),
             requests_per_second: totalDuration > 0 ? (totalRequests / totalDuration) : 0,
             bytes_per_second: responseSizes.length > 0 && totalDuration > 0

package/dist/protocols/rest/handler.d.ts

@@ -64,4 +64,10 @@ export declare class RESTHandler implements ProtocolHandler {
      * Format: "iteration. step_name vu_id-iteration"
      */
     private generateThreadName;
+    /**
+     * Normalize debug config to support user-friendly aliases
+     * Maps: log_requests, log_responses, log_headers, log_body, log_timings
+     * To internal names used by the handler
+     */
+    private normalizeDebugConfig;
 }

package/dist/protocols/rest/handler.js

@@ -44,7 +44,8 @@ const logger_1 = require("../../utils/logger");
 class RESTHandler {
     constructor(baseURL, defaultHeaders, timeout, debugConfig) {
         this.connectionTimings = new Map();
-        this.debugConfig = debugConfig;
+        // Normalize debug config to support user-friendly aliases
+        this.debugConfig = this.normalizeDebugConfig(debugConfig);
         // Create custom HTTP agent with socket timing hooks
         const httpAgent = new http.Agent({
             keepAlive: true,
@@ -772,5 +773,32 @@ class RESTHandler {
         const vuId = context.vu_id;
         return `${iteration}. ${stepName} ${vuId}-${iteration}`;
     }
+    /**
+     * Normalize debug config to support user-friendly aliases
+     * Maps: log_requests, log_responses, log_headers, log_body, log_timings
+     * To internal names used by the handler
+     */
+    normalizeDebugConfig(config) {
+        if (!config)
+            return undefined;
+        const normalized = { ...config };
+        // If any of the user-friendly log_* options are set, enable debug logging
+        const hasUserFriendlyOptions = config.log_requests || config.log_responses ||
+            config.log_headers || config.log_body || config.log_timings;
+        if (hasUserFriendlyOptions) {
+            // Set log level to debug to enable logging
+            normalized.log_level = normalized.log_level || 'debug';
+            // Map user-friendly names to internal names
+            if (config.log_headers) {
+                normalized.capture_request_headers = true;
+                normalized.capture_response_headers = true;
+            }
+            if (config.log_body) {
+                normalized.capture_request_body = true;
+                normalized.capture_response_body = true;
+            }
+        }
+        return normalized;
+    }
 }
 exports.RESTHandler = RESTHandler;

package/dist/protocols/web/core-web-vitals.js

@@ -286,21 +286,31 @@ class VerificationMetricsCollector {
         }
         catch (error) {
             error_message = error.message;
-            throw error;
-        }
-        finally {
-            // Round to 1 decimal place for cleaner output
+            // Calculate duration and metrics before re-throwing
             const duration = Math.round((performance.now() - startTime) * 10) / 10;
             const metrics = {
                 step_name: stepName,
                 step_type: stepType,
                 duration,
-                success,
+                success: false,
                 error_message,
                 ...additionalMetrics
             };
-            return { result: result, metrics };
+            // Attach metrics to error so caller can access them
+            error.verificationMetrics = metrics;
+            throw error;
         }
+        // Round to 1 decimal place for cleaner output
+        const duration = Math.round((performance.now() - startTime) * 10) / 10;
+        const metrics = {
+            step_name: stepName,
+            step_type: stepType,
+            duration,
+            success,
+            error_message,
+            ...additionalMetrics
+        };
+        return { result: result, metrics };
     }
     static generateVerificationThresholds(metrics) {
         const thresholds = [];

package/dist/protocols/web/handler.js

@@ -196,6 +196,27 @@ class WebHandler {
                 'measure_web_vitals', 'performance_audit'
             ];
             const shouldRecord = measurableCommands.includes(action.command);
+            // Check if verification took too long (>= 95% of timeout = effective timeout)
+            // If it completed right at the timeout boundary, treat it as a timeout failure
+            const timeout = action.timeout || 30000;
+            const timeoutThreshold = timeout * 0.95; // 95% of timeout
+            const isEffectiveTimeout = responseTime && responseTime >= timeoutThreshold && measurableCommands.includes(action.command);
+            if (isEffectiveTimeout) {
+                return {
+                    success: false,
+                    error: `Verification timeout: took ${responseTime}ms (>= ${timeoutThreshold}ms threshold)`,
+                    shouldRecord: true,
+                    response_time: responseTime,
+                    custom_metrics: {
+                        page_url: page.url(),
+                        page_title: await page.title(),
+                        vu_id: context.vu_id,
+                        command: action.command,
+                        timeout_threshold: timeoutThreshold,
+                        verification_metrics: verificationMetrics
+                    }
+                };
+            }
             const enhancedResult = {
                 success: true,
                 data: result,
@@ -217,14 +238,28 @@ class WebHandler {
             return enhancedResult;
         }
         catch (error) {
+            // Only record errors for measurable commands (verifications/waits) in step statistics
+            // Non-measurable command errors (click, fill, etc.) still appear in the errors table
+            // via the error tracking in virtual-user.ts, but not in step performance statistics
+            const measurableCommands = [
+                'verify_exists', 'verify_visible', 'verify_text', 'verify_contains', 'verify_not_exists',
+                'wait_for_selector', 'wait_for_text',
+                'measure_web_vitals', 'performance_audit'
+            ];
+            const shouldRecordError = measurableCommands.includes(action.command);
+            // Get verification metrics from error if available (attached by measureVerificationStep)
+            const verificationMetrics = error.verificationMetrics;
             return {
                 success: false,
                 error: error.message,
-                shouldRecord: true, // Record errors too for analysis
+                shouldRecord: shouldRecordError,
+                response_time: verificationMetrics?.duration,
                 custom_metrics: {
                     vu_id: context.vu_id,
+                    command: action.command,
                     error_type: error.constructor.name,
-                    error_stack: error.stack?.split('\n').slice(0, 3).join('; ')
+                    error_stack: error.stack?.split('\n').slice(0, 3).join('; '),
+                    verification_metrics: verificationMetrics
                 }
             };
         }

package/dist/workers/manager.d.ts

@@ -6,6 +6,7 @@ export declare class WorkerManager extends EventEmitter {
     private aggregatedMetrics;
     addWorker(address: string): Promise<void>;
     distributeTest(config: TestConfiguration): Promise<void>;
+    private scaleLoadConfig;
     waitForCompletion(): Promise<void>;
     getAggregatedMetrics(): MetricsCollector;
     cleanup(): Promise<void>;

package/dist/workers/manager.js

@@ -48,19 +48,36 @@ class WorkerManager extends events_1.EventEmitter {
             const workerVUs = Math.min(vusPerWorker, totalVUs - (index * vusPerWorker));
             if (workerVUs <= 0)
                 return;
+            // Properly scale load config for this worker
+            const scaledLoad = this.scaleLoadConfig(config.load, workerVUs);
             const workerConfig = {
                 ...config,
                 name: `${config.name} - Worker ${index + 1}`,
-                load: {
-                    ...config.load,
-                    virtual_users: workerVUs
-                }
+                load: scaledLoad
             };
             logger_1.logger.debug(`🎯 Assigning ${workerVUs} VUs to worker ${worker.getAddress()}`);
             return worker.executeTest(workerConfig);
         });
         await Promise.all(promises);
     }
+    scaleLoadConfig(load, vus) {
+        if (Array.isArray(load)) {
+            // Scale each phase in the array
+            return load.map(phase => ({
+                ...phase,
+                virtual_users: vus,
+                vus: vus
+            }));
+        }
+        else {
+            // Single phase object
+            return {
+                ...load,
+                virtual_users: vus,
+                vus: vus
+            };
+        }
+    }
     async waitForCompletion() {
         logger_1.logger.info('⏳ Waiting for all workers to complete...');
         const promises = this.workers.map(worker => worker.waitForCompletion());
@@ -72,9 +89,19 @@ class WorkerManager extends events_1.EventEmitter {
     }
     async cleanup() {
         logger_1.logger.info('🧹 Cleaning up workers...');
+        // Remove all event listeners from workers before disconnecting
+        for (const worker of this.workers) {
+            worker.removeAllListeners();
+        }
+        // Disconnect all workers
         const promises = this.workers.map(worker => worker.disconnect());
         await Promise.all(promises);
         this.workers = [];
+        // Finalize metrics to clear any timers
+        await this.aggregatedMetrics.finalize();
+        // Remove our own listeners
+        this.removeAllListeners();
+        logger_1.logger.info('✅ Cleanup completed');
     }
     getWorkerCount() {
         return this.workers.length;

package/dist/workers/worker.js

@@ -133,7 +133,10 @@ class WorkerNode extends events_1.EventEmitter {
     async disconnect() {
         this.isRunning = false;
         if (this.ws) {
-            this.ws.close();
+            // Remove all listeners to prevent memory leaks and allow process to exit
+            this.ws.removeAllListeners();
+            // Use terminate() for immediate close instead of close() which waits for graceful handshake
+            this.ws.terminate();
             this.ws = undefined;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testsmith/perfornium",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Flexible performance testing framework for REST, SOAP, and web applications",
   "author": "TestSmith",
   "license": "MIT",
@@ -48,7 +48,15 @@
     "dev": "tsc --watch",
     "dev:link": "npm run build && npm link",
     "dev:test": "npm run build && node dist/cli/cli.js",
-    "report:web-vitals": "node generate-web-vitals-report.js"
+    "report:web-vitals": "node generate-web-vitals-report.js",
+    "docker:build:controller": "docker build -t perfornium/controller -f docker/Dockerfile.controller .",
+    "docker:build:worker": "docker build -t perfornium/worker -f docker/Dockerfile.worker .",
+    "docker:build:worker-slim": "docker build -t perfornium/worker-slim -f docker/Dockerfile.worker-slim .",
+    "docker:build:all": "npm run docker:build:controller && npm run docker:build:worker && npm run docker:build:worker-slim",
+    "docker:up": "docker compose -f docker/docker-compose.yml up -d worker-1 worker-2 worker-3",
+    "docker:up:slim": "docker compose -f docker/docker-compose.slim.yml up -d worker-1 worker-2 worker-3",
+    "docker:down": "docker compose -f docker/docker-compose.yml down",
+    "docker:logs": "docker compose -f docker/docker-compose.yml logs -f"
   },
   "keywords": [
     "performance",