@testsmith/perfornium 0.1.0

package/dist/utils/timestamp-helper.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampHelper = void 0;
+/**
+ * Enhanced timestamp utility for file naming and templating
+ */
+class TimestampHelper {
+    /**
+     * Generate various timestamp formats
+     */
+    static getTimestamp(format = 'unix') {
+        const now = new Date();
+        switch (format) {
+            case 'unix':
+                return Date.now().toString();
+            case 'iso':
+                return now.toISOString();
+            case 'readable':
+                return now.toLocaleString().replace(/[/\s:]/g, '-');
+            case 'file': {
+                // Safe for filenames: YYYYMMDD-HHMMSS-mmm
+                const year = now.getFullYear();
+                const month = String(now.getMonth() + 1).padStart(2, '0');
+                const day = String(now.getDate()).padStart(2, '0');
+                const hour = String(now.getHours()).padStart(2, '0');
+                const minute = String(now.getMinutes()).padStart(2, '0');
+                const second = String(now.getSeconds()).padStart(2, '0');
+                const ms = String(now.getMilliseconds()).padStart(3, '0');
+                return `${year}${month}${day}-${hour}${minute}${second}-${ms}`;
+            }
+            default:
+                return Date.now().toString();
+        }
+    }
+    /**
+     * Create filename with timestamp ensuring directory exists
+     */
+    static createTimestampedPath(template, format = 'file') {
+        const timestamp = this.getTimestamp(format);
+        return template.replace(/\{\{timestamp\}\}/g, timestamp);
+    }
+    /**
+     * Generate filename ensuring uniqueness
+     */
+    static generateUniqueFilename(baseTemplate) {
+        const timestamp = this.getTimestamp('file');
+        const random = Math.floor(Math.random() * 1000).toString().padStart(3, '0');
+        return baseTemplate
+            .replace(/\{\{timestamp\}\}/g, timestamp)
+            .replace(/\{\{unique\}\}/g, `${timestamp}-${random}`);
+    }
+}
+exports.TimestampHelper = TimestampHelper;

package/dist/workers/manager.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from 'events';
+import { TestConfiguration } from '../config/types';
+import { MetricsCollector } from '../metrics/collector';
+export declare class WorkerManager extends EventEmitter {
+    private workers;
+    private aggregatedMetrics;
+    addWorker(address: string): Promise<void>;
+    distributeTest(config: TestConfiguration): Promise<void>;
+    waitForCompletion(): Promise<void>;
+    getAggregatedMetrics(): MetricsCollector;
+    cleanup(): Promise<void>;
+    getWorkerCount(): number;
+    getWorkerStatuses(): Array<{
+        address: string;
+        connected: boolean;
+    }>;
+    private removeWorker;
+}

package/dist/workers/manager.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerManager = void 0;
+const events_1 = require("events");
+const collector_1 = require("../metrics/collector");
+const worker_1 = require("./worker");
+const logger_1 = require("../utils/logger");
+class WorkerManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.workers = [];
+        this.aggregatedMetrics = new collector_1.MetricsCollector();
+    }
+    async addWorker(address) {
+        try {
+            const worker = new worker_1.WorkerNode(address);
+            await worker.connect();
+            worker.on('result', (result) => {
+                this.aggregatedMetrics.recordResult(result);
+                this.emit('result', result);
+            });
+            worker.on('error', (error) => {
+                logger_1.logger.error(`❌ Worker ${address} error:`, error);
+                this.emit('worker-error', { worker: address, error });
+            });
+            worker.on('disconnected', () => {
+                logger_1.logger.warn(`⚠️  Worker ${address} disconnected`);
+                this.removeWorker(worker);
+            });
+            this.workers.push(worker);
+            logger_1.logger.info(`✅ Worker added: ${address}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ Failed to add worker ${address}:`, error);
+            throw error;
+        }
+    }
+    async distributeTest(config) {
+        if (this.workers.length === 0) {
+            throw new Error('No workers available for distributed testing');
+        }
+        const { getPrimaryLoadPhase } = require('../config/types/load-config');
+        const primaryPhase = getPrimaryLoadPhase(config.load);
+        const totalVUs = primaryPhase.virtual_users || primaryPhase.vus || 1;
+        const vusPerWorker = Math.ceil(totalVUs / this.workers.length);
+        logger_1.logger.info(`🔄 Distributing ${totalVUs} VUs across ${this.workers.length} workers`);
+        const promises = this.workers.map(async (worker, index) => {
+            const workerVUs = Math.min(vusPerWorker, totalVUs - (index * vusPerWorker));
+            if (workerVUs <= 0)
+                return;
+            const workerConfig = {
+                ...config,
+                name: `${config.name} - Worker ${index + 1}`,
+                load: {
+                    ...config.load,
+                    virtual_users: workerVUs
+                }
+            };
+            logger_1.logger.debug(`🎯 Assigning ${workerVUs} VUs to worker ${worker.getAddress()}`);
+            return worker.executeTest(workerConfig);
+        });
+        await Promise.all(promises);
+    }
+    async waitForCompletion() {
+        logger_1.logger.info('⏳ Waiting for all workers to complete...');
+        const promises = this.workers.map(worker => worker.waitForCompletion());
+        await Promise.all(promises);
+        logger_1.logger.info('✅ All workers completed');
+    }
+    getAggregatedMetrics() {
+        return this.aggregatedMetrics;
+    }
+    async cleanup() {
+        logger_1.logger.info('🧹 Cleaning up workers...');
+        const promises = this.workers.map(worker => worker.disconnect());
+        await Promise.all(promises);
+        this.workers = [];
+    }
+    getWorkerCount() {
+        return this.workers.length;
+    }
+    getWorkerStatuses() {
+        return this.workers.map(worker => ({
+            address: worker.getAddress(),
+            connected: worker.isConnected()
+        }));
+    }
+    removeWorker(worker) {
+        const index = this.workers.indexOf(worker);
+        if (index > -1) {
+            this.workers.splice(index, 1);
+        }
+    }
+}
+exports.WorkerManager = WorkerManager;

package/dist/workers/server.d.ts

@@ -0,0 +1,21 @@
+export declare class WorkerServer {
+    private server;
+    private wss;
+    private port;
+    private host;
+    private activeRunners;
+    constructor(port?: number, host?: string);
+    private setupWebSocketHandlers;
+    private handleMessage;
+    private executeTest;
+    private stopTest;
+    private sendMessage;
+    private sendError;
+    private sendHeartbeat;
+    private cleanup;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getActiveConnections(): number;
+    getActiveTests(): number;
+    getStatus(): any;
+}

package/dist/workers/server.js

@@ -0,0 +1,205 @@
+"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.WorkerServer = void 0;
+const http = __importStar(require("http"));
+const WebSocket = __importStar(require("ws"));
+const test_runner_1 = require("../core/test-runner");
+const logger_1 = require("../utils/logger");
+class WorkerServer {
+    constructor(port = 8080, host = 'localhost') {
+        this.activeRunners = new Map();
+        this.port = port;
+        this.host = host;
+        this.server = http.createServer();
+        this.wss = new WebSocket.Server({
+            server: this.server,
+            path: '/perfornium'
+        });
+        this.setupWebSocketHandlers();
+    }
+    setupWebSocketHandlers() {
+        this.wss.on('connection', (ws, req) => {
+            const clientIP = req.socket.remoteAddress;
+            logger_1.logger.info(`👤 Worker client connected from ${clientIP}`);
+            ws.on('message', async (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    await this.handleMessage(ws, message);
+                }
+                catch (error) {
+                    logger_1.logger.error('❌ Error handling message:', error);
+                    this.sendError(ws, 'Invalid message format');
+                }
+            });
+            ws.on('close', () => {
+                logger_1.logger.info('👋 Worker client disconnected');
+                this.cleanup(ws);
+            });
+            ws.on('error', (error) => {
+                logger_1.logger.error('❌ WebSocket error:', error);
+                this.cleanup(ws);
+            });
+            // Send initial heartbeat
+            this.sendHeartbeat(ws);
+        });
+    }
+    async handleMessage(ws, message) {
+        switch (message.type) {
+            case 'execute_test':
+                await this.executeTest(ws, message.config);
+                break;
+            case 'stop_test':
+                await this.stopTest(ws);
+                break;
+            case 'heartbeat_ack':
+                // Client is alive, do nothing
+                break;
+            default:
+                logger_1.logger.warn(`⚠️  Unknown message type: ${message.type}`);
+        }
+    }
+    async executeTest(ws, config) {
+        try {
+            // Stop any existing test for this connection
+            await this.stopTest(ws);
+            logger_1.logger.info(`🚀 Starting test: ${config.name}`);
+            const runner = new test_runner_1.TestRunner(config);
+            this.activeRunners.set(ws, runner);
+            // Forward results to coordinator
+            runner.getMetrics().on('result', (result) => {
+                this.sendMessage(ws, {
+                    type: 'test_result',
+                    data: result
+                });
+            });
+            // Execute test
+            await runner.run();
+            // Test completed
+            const summary = runner.getMetrics().getSummary();
+            this.sendMessage(ws, {
+                type: 'test_completed',
+                summary: summary
+            });
+            logger_1.logger.info(`✅ Test completed: ${config.name}`);
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Test execution failed:', error);
+            this.sendError(ws, error.message);
+        }
+        finally {
+            this.activeRunners.delete(ws);
+        }
+    }
+    async stopTest(ws) {
+        const runner = this.activeRunners.get(ws);
+        if (runner) {
+            logger_1.logger.info('⏹️  Stopping test...');
+            await runner.stop();
+            this.activeRunners.delete(ws);
+        }
+    }
+    sendMessage(ws, message) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    sendError(ws, error) {
+        this.sendMessage(ws, {
+            type: 'test_error',
+            error: error,
+            timestamp: Date.now()
+        });
+    }
+    sendHeartbeat(ws) {
+        const interval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+                this.sendMessage(ws, {
+                    type: 'heartbeat',
+                    timestamp: Date.now()
+                });
+            }
+            else {
+                clearInterval(interval);
+            }
+        }, 30000); // 30 seconds
+    }
+    cleanup(ws) {
+        const runner = this.activeRunners.get(ws);
+        if (runner) {
+            runner.stop().catch(err => logger_1.logger.error('❌ Error stopping runner during cleanup:', err));
+            this.activeRunners.delete(ws);
+        }
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server.listen(this.port, this.host, () => {
+                logger_1.logger.info(`🚀 Worker server started on ${this.host}:${this.port}`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            // Stop all active tests
+            for (const [, runner] of this.activeRunners) {
+                runner.stop().catch(err => logger_1.logger.error('❌ Error stopping runner:', err));
+            }
+            this.wss.close(() => {
+                this.server.close(() => {
+                    logger_1.logger.info('👋 Worker server stopped');
+                    resolve();
+                });
+            });
+        });
+    }
+    getActiveConnections() {
+        return this.wss.clients.size;
+    }
+    getActiveTests() {
+        return this.activeRunners.size;
+    }
+    getStatus() {
+        return {
+            host: this.host,
+            port: this.port,
+            active_connections: this.getActiveConnections(),
+            active_tests: this.getActiveTests(),
+            uptime: process.uptime(),
+            memory_usage: process.memoryUsage()
+        };
+    }
+}
+exports.WorkerServer = WorkerServer;

package/dist/workers/worker.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from 'events';
+import { TestConfiguration } from '../config/types';
+export declare class WorkerNode extends EventEmitter {
+    private address;
+    private ws?;
+    private isRunning;
+    private connectionRetries;
+    private maxRetries;
+    constructor(address: string);
+    connect(): Promise<void>;
+    executeTest(config: TestConfiguration): Promise<void>;
+    private handleMessage;
+    private sendHeartbeat;
+    waitForCompletion(): Promise<void>;
+    stop(): Promise<void>;
+    disconnect(): Promise<void>;
+    getAddress(): string;
+    isConnected(): boolean;
+}

package/dist/workers/worker.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerNode = void 0;
+const events_1 = require("events");
+const ws_1 = __importDefault(require("ws"));
+const logger_1 = require("../utils/logger");
+class WorkerNode extends events_1.EventEmitter {
+    constructor(address) {
+        super();
+        this.isRunning = false;
+        this.connectionRetries = 0;
+        this.maxRetries = 3;
+        this.address = address;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const wsUrl = `ws://${this.address}/perfornium`;
+            logger_1.logger.debug(`🔌 Connecting to worker: ${wsUrl}`);
+            this.ws = new ws_1.default(wsUrl);
+            const timeout = setTimeout(() => {
+                reject(new Error(`Connection timeout to worker ${this.address}`));
+            }, 10000);
+            this.ws.on('open', () => {
+                clearTimeout(timeout);
+                this.connectionRetries = 0;
+                logger_1.logger.debug(`✅ Connected to worker: ${this.address}`);
+                resolve();
+            });
+            this.ws.on('error', (error) => {
+                clearTimeout(timeout);
+                logger_1.logger.error(`❌ Connection error to worker ${this.address}:`, error);
+                reject(error);
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(message);
+                }
+                catch (error) {
+                    logger_1.logger.error('❌ Invalid message from worker:', error);
+                }
+            });
+            this.ws.on('close', (code, reason) => {
+                logger_1.logger.debug(`🔌 Worker ${this.address} disconnected: ${code} ${reason}`);
+                this.emit('disconnected');
+                // Attempt reconnection if unexpected disconnect
+                if (this.isRunning && this.connectionRetries < this.maxRetries) {
+                    this.connectionRetries++;
+                    logger_1.logger.info(`🔄 Attempting to reconnect to worker ${this.address} (${this.connectionRetries}/${this.maxRetries})`);
+                    setTimeout(() => this.connect(), 5000);
+                }
+            });
+        });
+    }
+    async executeTest(config) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            throw new Error(`Worker ${this.address} is not connected`);
+        }
+        this.isRunning = true;
+        const message = {
+            type: 'execute_test',
+            config: config,
+            timestamp: Date.now()
+        };
+        logger_1.logger.debug(`🚀 Starting test on worker ${this.address}`);
+        this.ws.send(JSON.stringify(message));
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            case 'test_result':
+                this.emit('result', message.data);
+                break;
+            case 'test_progress':
+                logger_1.logger.debug(`📊 Worker ${this.address} progress: ${message.data.completed}/${message.data.total}`);
+                this.emit('progress', message.data);
+                break;
+            case 'test_completed':
+                this.isRunning = false;
+                logger_1.logger.info(`✅ Worker ${this.address} completed test`);
+                this.emit('completed', message.summary);
+                break;
+            case 'test_error':
+                this.isRunning = false;
+                logger_1.logger.error(`❌ Worker ${this.address} test error: ${message.error}`);
+                this.emit('error', new Error(message.error));
+                break;
+            case 'heartbeat':
+                this.sendHeartbeat();
+                break;
+            case 'log':
+                logger_1.logger.debug(`📝 Worker ${this.address}: ${message.message}`);
+                break;
+            default:
+                logger_1.logger.warn(`⚠️  Unknown message type from worker ${this.address}: ${message.type}`);
+        }
+    }
+    sendHeartbeat() {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: 'heartbeat_ack',
+                timestamp: Date.now()
+            }));
+        }
+    }
+    async waitForCompletion() {
+        return new Promise((resolve, reject) => {
+            if (!this.isRunning) {
+                resolve();
+                return;
+            }
+            const timeout = setTimeout(() => {
+                reject(new Error(`Worker ${this.address} completion timeout`));
+            }, 300000); // 5 minute timeout
+            this.once('completed', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.once('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify({ type: 'stop_test' }));
+        }
+        this.isRunning = false;
+    }
+    async disconnect() {
+        this.isRunning = false;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+    }
+    getAddress() {
+        return this.address;
+    }
+    isConnected() {
+        return this.ws?.readyState === ws_1.default.OPEN;
+    }
+}
+exports.WorkerNode = WorkerNode;

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@testsmith/perfornium",
+  "version": "0.1.0",
+  "description": "Flexible performance testing framework for REST, SOAP, and web applications",
+  "author": "TestSmith",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/testsmith-io/perfornium.git"
+  },
+  "homepage": "https://github.com/testsmith-io/perfornium#readme",
+  "bugs": {
+    "url": "https://github.com/testsmith-io/perfornium/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "perfornium": "dist/cli/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dsl": {
+      "types": "./dist/dsl/index.d.ts",
+      "default": "./dist/dsl/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-templates",
+    "copy-templates": "mkdir -p dist/reporting/templates && cp -r src/reporting/templates/* dist/reporting/templates/ 2>/dev/null || true",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest --coverage",
+    "test:ui": "vitest --ui",
+    "benchmark": "npm run build && node --expose-gc dist/benchmarks/performance-tests.js",
+    "prepare": "npm run build",
+    "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"
+  },
+  "keywords": [
+    "performance",
+    "testing",
+    "load-testing",
+    "rest",
+    "soap",
+    "web",
+    "playwright"
+  ],
+  "dependencies": {
+    "@faker-js/faker": "^9.9.0",
+    "@types/papaparse": "^5.3.16",
+    "@xmldom/xmldom": "^0.8.11",
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "csv-parse": "^5.5.0",
+    "csv-writer": "^1.6.0",
+    "esbuild": "^0.27.1",
+    "handlebars": "^4.7.0",
+    "influx": "^5.10.0",
+    "inquirer": "^12.9.4",
+    "js-yaml": "^4.1.0",
+    "ora": "^8.2.0",
+    "papaparse": "^5.5.3",
+    "playwright": "^1.40.0",
+    "soap": "^1.0.0",
+    "ws": "^8.14.0",
+    "yaml": "^2.3.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/handlebars": "^4.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "@types/xmldom": "^0.1.34",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/parser": "^8.49.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "@vitest/ui": "^1.0.0",
+    "eslint": "^9.39.2",
+    "typescript": "^5.2.0",
+    "typescript-eslint": "^8.49.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}