@testsmith/perfornium 0.1.0

package/dist/core/threshold-evaluator.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThresholdEvaluator = void 0;
+const logger_1 = require("../utils/logger");
+class ThresholdEvaluator {
+    /**
+     * Evaluate all thresholds against a test result
+     */
+    static evaluate(thresholds, result, stepName) {
+        const failures = [];
+        for (const threshold of thresholds) {
+            try {
+                const failure = this.evaluateThreshold(threshold, result, stepName);
+                if (failure) {
+                    failures.push(failure);
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`Error evaluating threshold for metric ${threshold.metric}: ${error}`);
+                failures.push({
+                    threshold,
+                    actualValue: 'ERROR',
+                    expectedValue: threshold.value,
+                    message: `Threshold evaluation failed: ${error}`,
+                    severity: 'error'
+                });
+            }
+        }
+        return {
+            passed: failures.length === 0,
+            failures
+        };
+    }
+    /**
+     * Evaluate a single threshold
+     */
+    static evaluateThreshold(threshold, result, stepName) {
+        const actualValue = this.extractMetricValue(threshold.metric, result);
+        const expectedValue = this.parseExpectedValue(threshold.value);
+        const operator = threshold.operator || 'lte'; // Default to less than or equal
+        const passed = this.compareValues(actualValue, expectedValue, operator);
+        if (!passed) {
+            const stepInfo = stepName ? ` in step "${stepName}"` : '';
+            const description = threshold.description ||
+                `${threshold.metric} threshold exceeded${stepInfo}`;
+            return {
+                threshold,
+                actualValue,
+                expectedValue,
+                message: `${description}: ${actualValue} ${this.getOperatorSymbol(operator)} ${expectedValue}`,
+                severity: threshold.severity || 'error'
+            };
+        }
+        return null;
+    }
+    /**
+     * Extract the actual metric value from test result
+     */
+    static extractMetricValue(metric, result) {
+        switch (metric) {
+            case 'response_time':
+                return result.duration;
+            case 'status_code':
+                return result.status || 0;
+            case 'error_rate':
+                // This would need to be calculated at a higher level
+                // For now, return 0 for success, 100 for failure
+                return result.success ? 0 : 100;
+            case 'throughput':
+                // Calculate requests per second (would need time window context)
+                return result.duration > 0 ? 1000 / result.duration : 0;
+            case 'custom':
+                // Custom metrics would be stored in result.custom_metrics
+                return result.custom_metrics || 0;
+            default:
+                throw new Error(`Unknown metric type: ${metric}`);
+        }
+    }
+    /**
+     * Parse expected value, handling units like "1s", "500ms", etc.
+     */
+    static parseExpectedValue(value) {
+        if (typeof value === 'number') {
+            return value;
+        }
+        const str = value.toString().toLowerCase();
+        // Handle time units
+        if (str.endsWith('ms')) {
+            return parseFloat(str.slice(0, -2));
+        }
+        if (str.endsWith('s')) {
+            return parseFloat(str.slice(0, -1)) * 1000; // Convert to ms
+        }
+        if (str.endsWith('m')) {
+            return parseFloat(str.slice(0, -1)) * 60000; // Convert to ms
+        }
+        // Handle percentage
+        if (str.endsWith('%')) {
+            return parseFloat(str.slice(0, -1));
+        }
+        // Default: try to parse as number
+        const parsed = parseFloat(str);
+        if (isNaN(parsed)) {
+            throw new Error(`Cannot parse threshold value: ${value}`);
+        }
+        return parsed;
+    }
+    /**
+     * Compare actual vs expected values using the specified operator
+     */
+    static compareValues(actual, expected, operator) {
+        const actualNum = typeof actual === 'string' ? parseFloat(actual.toString()) : actual;
+        if (isNaN(actualNum)) {
+            return operator === 'ne'; // Only "not equals" passes for non-numeric values
+        }
+        switch (operator) {
+            case 'lt': return actualNum < expected;
+            case 'lte': return actualNum <= expected;
+            case 'gt': return actualNum > expected;
+            case 'gte': return actualNum >= expected;
+            case 'eq': return actualNum === expected;
+            case 'ne': return actualNum !== expected;
+            default:
+                throw new Error(`Unknown operator: ${operator}`);
+        }
+    }
+    /**
+     * Get human-readable operator symbol
+     */
+    static getOperatorSymbol(operator) {
+        const symbols = {
+            'lt': '<',
+            'lte': '≤',
+            'gt': '>',
+            'gte': '≥',
+            'eq': '=',
+            'ne': '≠'
+        };
+        return symbols[operator] || operator;
+    }
+    /**
+     * Execute threshold action based on severity and configuration
+     */
+    static async executeThresholdActions(evaluationResult, stepName) {
+        for (const failure of evaluationResult.failures) {
+            const action = failure.threshold.action || 'log';
+            const stepInfo = stepName ? ` [Step: ${stepName}]` : '';
+            switch (action) {
+                case 'log':
+                    logger_1.logger.warn(`Threshold violation${stepInfo}: ${failure.message}`);
+                    break;
+                case 'fail_step':
+                    logger_1.logger.error(`Step threshold violation${stepInfo}: ${failure.message}`);
+                    throw new Error(`Step failed due to threshold violation: ${failure.message}`);
+                case 'fail_scenario':
+                    logger_1.logger.error(`Scenario threshold violation${stepInfo}: ${failure.message}`);
+                    throw new Error(`Scenario failed due to threshold violation: ${failure.message}`);
+                case 'fail_test':
+                    logger_1.logger.error(`Test threshold violation${stepInfo}: ${failure.message}`);
+                    throw new Error(`Test failed due to threshold violation: ${failure.message}`);
+                case 'abort':
+                    logger_1.logger.error(`Critical threshold violation${stepInfo}: ${failure.message}`);
+                    process.exit(1);
+                default:
+                    logger_1.logger.warn(`Unknown threshold action: ${action}`);
+            }
+        }
+    }
+}
+exports.ThresholdEvaluator = ThresholdEvaluator;

package/dist/core/virtual-user-pool.d.ts

@@ -0,0 +1,42 @@
+import { VirtualUser } from './virtual-user';
+import { MetricsCollector } from '../metrics/collector';
+import { ProtocolHandler } from '../protocols/base';
+import { Scenario } from '../config/types/hooks';
+import { EventEmitter } from 'events';
+export interface VUPoolConfig {
+    maxWorkers?: number;
+    maxVUsPerWorker?: number;
+    reuseVUs?: boolean;
+    preWarmVUs?: number;
+    workerIdleTimeout?: number;
+}
+export interface VUTask {
+    id: number;
+    scenarios: Scenario[];
+    priority?: number;
+}
+export declare class VirtualUserPool extends EventEmitter {
+    private config;
+    private metrics;
+    private handlers;
+    private testName;
+    private vuPool;
+    private availableVUs;
+    private busyVUs;
+    private workers;
+    private taskQueue;
+    private nextVUId;
+    private readonly DEFAULT_MAX_WORKERS;
+    private readonly DEFAULT_MAX_VUS_PER_WORKER;
+    private readonly DEFAULT_WORKER_IDLE_TIMEOUT;
+    constructor(metrics: MetricsCollector, handlers: Map<string, ProtocolHandler>, testName?: string, config?: VUPoolConfig);
+    initialize(): Promise<void>;
+    private preWarmVUs;
+    private createVU;
+    getVU(scenarios: Scenario[]): Promise<VirtualUser>;
+    releaseVU(vuId: number): void;
+    executeTask(task: VUTask): Promise<void>;
+    private startWorkerCleanup;
+    private terminateWorker;
+    shutdown(): Promise<void>;
+}

package/dist/core/virtual-user-pool.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualUserPool = void 0;
+const virtual_user_1 = require("./virtual-user");
+const logger_1 = require("../utils/logger");
+const events_1 = require("events");
+class VirtualUserPool extends events_1.EventEmitter {
+    constructor(metrics, handlers, testName = 'Load Test', config) {
+        super();
+        this.vuPool = new Map();
+        this.availableVUs = new Set();
+        this.busyVUs = new Set();
+        this.workers = new Map();
+        this.taskQueue = [];
+        this.nextVUId = 1;
+        this.DEFAULT_MAX_WORKERS = 4;
+        this.DEFAULT_MAX_VUS_PER_WORKER = 50;
+        this.DEFAULT_WORKER_IDLE_TIMEOUT = 30000;
+        this.metrics = metrics;
+        this.handlers = handlers;
+        this.testName = testName;
+        this.config = {
+            maxWorkers: config?.maxWorkers || this.DEFAULT_MAX_WORKERS,
+            maxVUsPerWorker: config?.maxVUsPerWorker || this.DEFAULT_MAX_VUS_PER_WORKER,
+            reuseVUs: config?.reuseVUs ?? true,
+            preWarmVUs: config?.preWarmVUs || 0,
+            workerIdleTimeout: config?.workerIdleTimeout || this.DEFAULT_WORKER_IDLE_TIMEOUT
+        };
+    }
+    async initialize() {
+        logger_1.logger.debug(`🏊 Initializing VU pool with config:`, this.config);
+        if (this.config.preWarmVUs && this.config.preWarmVUs > 0) {
+            await this.preWarmVUs(this.config.preWarmVUs);
+        }
+        this.startWorkerCleanup();
+    }
+    async preWarmVUs(count) {
+        logger_1.logger.debug(`🔥 Pre-warming ${count} virtual users...`);
+        const promises = [];
+        for (let i = 0; i < count; i++) {
+            promises.push(this.createVU());
+        }
+        await Promise.all(promises);
+        logger_1.logger.debug(`✅ Pre-warmed ${count} virtual users`);
+    }
+    async createVU() {
+        const vuId = this.nextVUId++;
+        const vu = new virtual_user_1.VirtualUser(vuId, this.metrics, this.handlers, this.testName);
+        this.vuPool.set(vuId, vu);
+        this.availableVUs.add(vuId);
+        return vuId;
+    }
+    async getVU(scenarios) {
+        let vuId;
+        if (this.config.reuseVUs && this.availableVUs.size > 0) {
+            const iterator = this.availableVUs.values().next();
+            if (!iterator.done) {
+                vuId = iterator.value;
+                this.availableVUs.delete(vuId);
+            }
+            else {
+                vuId = await this.createVU();
+            }
+        }
+        else {
+            vuId = await this.createVU();
+        }
+        this.busyVUs.add(vuId);
+        const vu = this.vuPool.get(vuId);
+        await vu.setScenarios(scenarios);
+        return vu;
+    }
+    releaseVU(vuId) {
+        if (!this.busyVUs.has(vuId)) {
+            return;
+        }
+        this.busyVUs.delete(vuId);
+        if (this.config.reuseVUs) {
+            this.availableVUs.add(vuId);
+        }
+        else {
+            const vu = this.vuPool.get(vuId);
+            if (vu) {
+                vu.stop();
+                this.vuPool.delete(vuId);
+            }
+        }
+    }
+    async executeTask(task) {
+        const vu = await this.getVU(task.scenarios);
+        try {
+            await vu.executeScenarios();
+        }
+        finally {
+            this.releaseVU(vu.getId());
+        }
+    }
+    startWorkerCleanup() {
+        if (!this.config.workerIdleTimeout || this.config.workerIdleTimeout <= 0) {
+            return;
+        }
+        setInterval(() => {
+            const now = Date.now();
+            for (const [workerId, state] of this.workers.entries()) {
+                if (state.isIdle &&
+                    state.activeVUs.size === 0 &&
+                    now - state.lastActivity > this.config.workerIdleTimeout) {
+                    this.terminateWorker(workerId);
+                }
+            }
+        }, 10000);
+    }
+    terminateWorker(workerId) {
+        const state = this.workers.get(workerId);
+        if (!state)
+            return;
+        state.worker.terminate();
+        this.workers.delete(workerId);
+        logger_1.logger.debug(`🧹 Terminated idle worker ${workerId}`);
+    }
+    async shutdown() {
+        logger_1.logger.debug('🛑 Shutting down VU pool...');
+        for (const [vuId, vu] of this.vuPool) {
+            await vu.stop();
+        }
+        for (const [workerId, state] of this.workers) {
+            await state.worker.terminate();
+        }
+        this.vuPool.clear();
+        this.availableVUs.clear();
+        this.busyVUs.clear();
+        this.workers.clear();
+        logger_1.logger.debug('✅ VU pool shut down complete');
+    }
+}
+exports.VirtualUserPool = VirtualUserPool;

package/dist/core/virtual-user.d.ts

@@ -0,0 +1,51 @@
+import { Scenario, VUHooks } from '../config/types/hooks';
+import { MetricsCollector } from '../metrics/collector';
+import { ProtocolHandler } from '../protocols/base';
+import { GlobalCSVConfig } from '../config';
+export interface GlobalCSVOptions {
+    config: GlobalCSVConfig;
+    mode?: 'next' | 'unique' | 'random';
+}
+export declare class VirtualUser {
+    private id;
+    private context;
+    private metrics;
+    private stepExecutor;
+    private isActive;
+    private scenarios;
+    private csvProviders;
+    private vuHooksManager;
+    private testName;
+    private handlers;
+    private globalThinkTime?;
+    private globalCSVProvider?;
+    private globalCSVMode?;
+    constructor(id: number, metrics: MetricsCollector, handlers: Map<string, ProtocolHandler>, testName?: string, vuHooks?: VUHooks, globalThinkTime?: string | number, globalCSV?: GlobalCSVOptions);
+    setScenarios(scenarios: Scenario[]): Promise<void>;
+    /**
+     * Initialize CSV providers only for scenarios that need them
+     */
+    private initializeCSVProvidersIfNeeded;
+    /**
+     * Load global CSV data and merge into context variables
+     * Called once at the start of each VU execution cycle
+     */
+    private loadGlobalCSVData;
+    executeScenarios(): Promise<void>;
+    executeScenario(scenario: Scenario): Promise<void>;
+    private loadCSVDataIfNeeded;
+    private loadCSVDataForScenario;
+    private selectScenarios;
+    private executeSetup;
+    private executeTeardown;
+    private executeScript;
+    /**
+     * Get effective think time using hierarchical override:
+     * Step think_time > Scenario think_time > Global think_time
+     */
+    private getEffectiveThinkTime;
+    private applyThinkTime;
+    stop(): Promise<void>;
+    getId(): number;
+    isRunning(): boolean;
+}