@testsmith/perfornium 0.1.0

package/dist/load-patterns/basic.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicPattern = void 0;
+const time_1 = require("../utils/time");
+const logger_1 = require("../utils/logger");
+class BasicPattern {
+    async execute(config, vuFactory) {
+        const virtualUsers = config.users || config.virtual_users || 1;
+        const rampUpMs = (0, time_1.parseTime)(config.ramp_up || '0s');
+        const durationMs = config.duration ? (0, time_1.parseTime)(config.duration) : null;
+        if (durationMs) {
+            logger_1.logger.info(`🎯 Basic load: ${virtualUsers} VUs, ramp-up: ${(rampUpMs / 1000).toFixed(1)}s, duration: ${(durationMs / 1000).toFixed(1)}s`);
+        }
+        else {
+            logger_1.logger.info(`🎯 Basic load: ${virtualUsers} VUs, ramp-up: ${(rampUpMs / 1000).toFixed(1)}s, run once`);
+        }
+        const intervalMs = rampUpMs > 0 ? rampUpMs / virtualUsers : 0;
+        const vuPromises = [];
+        // Start virtual users with ramp-up
+        for (let i = 0; i < virtualUsers; i++) {
+            const vuPromise = new Promise((resolve) => {
+                setTimeout(async () => {
+                    const vuStartTime = Date.now();
+                    try {
+                        // CRITICAL: Await VU creation to ensure CSV initialization
+                        logger_1.logger.debug(`Creating VU ${i + 1}...`);
+                        const vu = await this.createVU(vuFactory, i + 1);
+                        logger_1.logger.debug(`VU ${i + 1} ready`);
+                        // Record VU start for metrics and reporting
+                        const metrics = vuFactory.getMetrics();
+                        metrics.recordVUStart(vu.getId());
+                        logger_1.logger.debug(`👤 Started VU ${vu.getId()}`);
+                        if (durationMs) {
+                            // Run for specified duration
+                            await this.runVUForDuration(vu, durationMs, vuStartTime);
+                        }
+                        else {
+                            // Run scenarios once
+                            await this.runVUOnce(vu);
+                        }
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                            logger_1.logger.info(`⏹️ VU ${i + 1} terminated due to CSV data exhaustion`);
+                        }
+                        else {
+                            logger_1.logger.error(`❌ VU ${i + 1} error:`, error);
+                        }
+                    }
+                    finally {
+                        logger_1.logger.debug(`🏁 VU ${i + 1} completed`);
+                    }
+                    resolve();
+                }, i * intervalMs);
+            });
+            vuPromises.push(vuPromise);
+        }
+        // Wait for all VUs to complete (some may terminate early due to CSV exhaustion)
+        await Promise.all(vuPromises);
+        logger_1.logger.debug(`✅ Basic pattern completed`);
+    }
+    async createVU(vuFactory, id) {
+        const vu = vuFactory.create(id);
+        if (vu instanceof Promise) {
+            return await vu;
+        }
+        return vu;
+    }
+    async runVUOnce(vu) {
+        try {
+            if (vu.isRunning()) {
+                await vu.executeScenarios();
+                logger_1.logger.debug(`🏁 VU ${vu.getId()} completed scenario execution`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                // This is expected - VU stopped due to CSV exhaustion
+                throw error; // Re-throw to be caught by the calling code
+            }
+            logger_1.logger.error(`⚠ VU ${vu.getId()} error during execution:`, error);
+        }
+        finally {
+            vu.stop();
+            logger_1.logger.debug(`🏁 VU ${vu.getId()} completed and stopped`);
+        }
+    }
+    async runVUForDuration(vu, durationMs, startTime) {
+        const endTime = startTime + durationMs;
+        while (Date.now() < endTime && vu.isRunning()) {
+            try {
+                // Execute all scenarios for this VU
+                await vu.executeScenarios();
+                // Check if we still have time for another iteration
+                if (Date.now() >= endTime) {
+                    break;
+                }
+                // Small pause between full scenario loops
+                await (0, time_1.sleep)(100);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                    logger_1.logger.info(`⏹️ VU ${vu.getId()} terminated due to CSV data exhaustion`);
+                    break; // Exit the loop, but don't propagate the error
+                }
+                logger_1.logger.error(`❌ VU ${vu.getId()} error during execution:`, error);
+                break;
+            }
+        }
+        vu.stop();
+        logger_1.logger.debug(`🏁 VU ${vu.getId()} completed after ${((Date.now() - startTime) / 1000).toFixed(1)}s`);
+    }
+}
+exports.BasicPattern = BasicPattern;

package/dist/load-patterns/stepping.d.ts

@@ -0,0 +1,6 @@
+import { LoadPattern, VUFactory } from './base';
+export declare class SteppingPattern implements LoadPattern {
+    execute(config: any, vuFactory: VUFactory): Promise<void>;
+    private createVU;
+    private runVUForDuration;
+}

package/dist/load-patterns/stepping.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SteppingPattern = void 0;
+const time_1 = require("../utils/time");
+const logger_1 = require("../utils/logger");
+class SteppingPattern {
+    async execute(config, vuFactory) {
+        const steps = config.steps;
+        if (!steps || steps.length === 0) {
+            throw new Error('Stepping pattern requires steps configuration');
+        }
+        let currentVUs = 0;
+        const activeVUs = [];
+        logger_1.logger.info(`📊 Stepping load: ${steps.length} steps`);
+        for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+            const step = steps[stepIndex];
+            const targetUsers = step.users;
+            const stepDuration = (0, time_1.parseTime)(step.duration);
+            const rampUp = (0, time_1.parseTime)(step.ramp_up || '0s');
+            logger_1.logger.info(`📈 Step ${stepIndex + 1}/${steps.length}: ${currentVUs} → ${targetUsers} users over ${(stepDuration / 1000).toFixed(1)}s`);
+            if (targetUsers > currentVUs) {
+                // Scale up: Add new users
+                const usersToAdd = targetUsers - currentVUs;
+                const rampUpInterval = rampUp > 0 ? rampUp / usersToAdd : 0;
+                for (let i = 0; i < usersToAdd; i++) {
+                    setTimeout(async () => {
+                        const vuStartTime = Date.now();
+                        const vuEndTime = vuStartTime + stepDuration;
+                        const vuId = currentVUs + i + 1;
+                        try {
+                            // CRITICAL: Await VU creation to ensure CSV initialization
+                            logger_1.logger.debug(`Creating VU ${vuId}...`);
+                            const vu = await this.createVU(vuFactory, vuId);
+                            logger_1.logger.debug(`VU ${vuId} ready`);
+                            // Record VU start for metrics and reporting
+                            const metrics = vuFactory.getMetrics();
+                            metrics.recordVUStart(vu.getId());
+                            activeVUs.push({ vu, startTime: vuStartTime, endTime: vuEndTime });
+                            logger_1.logger.debug(`👤 Started VU ${vu.getId()}`);
+                            // Run VU for this step's duration
+                            await this.runVUForDuration(vu, stepDuration, vuStartTime);
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                                logger_1.logger.info(`⏹️ VU ${vuId} terminated due to CSV data exhaustion`);
+                            }
+                            else {
+                                logger_1.logger.error(`❌ Failed to create/run VU ${vuId}:`, error);
+                            }
+                        }
+                    }, i * rampUpInterval);
+                }
+                // Wait for ramp-up
+                if (rampUp > 0) {
+                    await (0, time_1.sleep)(rampUp);
+                }
+            }
+            else if (targetUsers < currentVUs) {
+                // Scale down: Stop some users
+                logger_1.logger.debug(`📉 Scaling down from ${currentVUs} to ${targetUsers} users`);
+                const usersToStop = currentVUs - targetUsers;
+                // Stop the most recently started VUs
+                const vusToStop = activeVUs
+                    .filter(vuInfo => vuInfo.vu.isRunning())
+                    .slice(-usersToStop);
+                vusToStop.forEach(vuInfo => {
+                    vuInfo.vu.stop();
+                    logger_1.logger.debug(`⏹️ Stopped VU ${vuInfo.vu.getId()}`);
+                });
+            }
+            currentVUs = targetUsers;
+            // Wait for step duration (minus ramp-up time)
+            const waitTime = Math.max(stepDuration - rampUp, 0);
+            if (waitTime > 0) {
+                await (0, time_1.sleep)(waitTime);
+            }
+        }
+        // Wait for all remaining VUs to complete
+        const remainingVUs = activeVUs.filter(vuInfo => vuInfo.vu.isRunning());
+        if (remainingVUs.length > 0) {
+            logger_1.logger.debug(`⏳ Waiting for ${remainingVUs.length} VUs to complete...`);
+            const maxEndTime = Math.max(...remainingVUs.map(vuInfo => vuInfo.endTime));
+            const waitTime = Math.max(maxEndTime - Date.now(), 0);
+            if (waitTime > 0) {
+                await (0, time_1.sleep)(waitTime);
+            }
+        }
+        logger_1.logger.debug('✅ Stepping pattern completed');
+    }
+    async createVU(vuFactory, id) {
+        // Handle both sync and async factories
+        const vu = vuFactory.create(id);
+        if (vu instanceof Promise) {
+            return await vu;
+        }
+        return vu;
+    }
+    async runVUForDuration(vu, durationMs, startTime) {
+        const endTime = startTime + durationMs;
+        while (Date.now() < endTime && vu.isRunning()) {
+            try {
+                await vu.executeScenarios();
+                if (Date.now() >= endTime) {
+                    break;
+                }
+                await (0, time_1.sleep)(100); // Small pause between iterations
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage.includes('terminated due to CSV data exhaustion')) {
+                    logger_1.logger.info(`⏹️ VU ${vu.getId()} terminated due to CSV data exhaustion`);
+                    break; // Exit the loop, VU is already stopped
+                }
+                logger_1.logger.error(`❌ VU ${vu.getId()} error:`, error);
+                break;
+            }
+        }
+        logger_1.logger.debug(`🏁 VU ${vu.getId()} completed step execution`);
+    }
+}
+exports.SteppingPattern = SteppingPattern;

package/dist/metrics/collector.d.ts

@@ -0,0 +1,72 @@
+import { MetricsSummary, TestResult } from './types';
+import { EventEmitter } from 'events';
+export interface RealtimeConfig {
+    enabled: boolean;
+    batch_size?: number;
+    interval_ms?: number;
+    endpoints?: RealtimeEndpoint[];
+    file_output?: {
+        enabled: boolean;
+        path: string;
+        format: 'jsonl' | 'csv';
+    };
+    incremental_files?: {
+        enabled: boolean;
+        json_path?: string;
+        csv_path?: string;
+        update_summary?: boolean;
+    };
+}
+export interface RealtimeEndpoint {
+    type: 'graphite' | 'webhook' | 'influxdb' | 'websocket';
+    url?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    token?: string;
+    headers?: Record<string, string>;
+}
+export declare class MetricsCollector extends EventEmitter {
+    private results;
+    private startTime;
+    private errorDetails;
+    private vuStartEvents;
+    private loadPatternType;
+    private realtimeConfig;
+    private batchBuffer;
+    private batchTimer;
+    private batchCounter;
+    private csvHeaderWritten;
+    private defaultJsonPath;
+    private defaultCsvPath;
+    constructor(realtimeConfig?: RealtimeConfig);
+    private initializeRealtime;
+    private startBatchTimer;
+    private initializeIncrementalFiles;
+    start(): void;
+    recordVUStart(vuId: number): void;
+    recordResult(result: TestResult): void;
+    recordError(vuId: number, scenario: string, action: string, error: Error): void;
+    private flushBatch;
+    private writeBatchToFile;
+    private formatBatchAsCSV;
+    private updateIncrementalFiles;
+    private updateIncrementalJSON;
+    private updateIncrementalCSV;
+    private updateIncrementalSummary;
+    private generateSimpleHTMLSummary;
+    private sendToRealTimeEndpoints;
+    private sendToEndpoint;
+    private sendToGraphite;
+    private sendToWebhook;
+    private sendToInfluxDB;
+    private sendToWebSocket;
+    finalize(): Promise<void>;
+    private trackErrorDetail;
+    getResults(): TestResult[];
+    getSummary(): MetricsSummary;
+    private calculateStepStatistics;
+    private calculateTimelineData;
+    private calculatePercentiles;
+    clear(): void;
+}