@testsmith/perfornium 0.1.0

package/dist/core/virtual-user.js

@@ -0,0 +1,488 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualUser = void 0;
+const step_executor_1 = require("./step-executor");
+const csv_data_provider_1 = require("./csv-data-provider");
+const hooks_manager_1 = require("./hooks-manager");
+const time_1 = require("../utils/time");
+const logger_1 = require("../utils/logger");
+class VirtualUser {
+    constructor(id, metrics, handlers, testName = 'Load Test', vuHooks, globalThinkTime, globalCSV) {
+        this.isActive = true;
+        this.scenarios = [];
+        this.csvProviders = new Map();
+        logger_1.logger.debug(`VirtualUser ${id} created`);
+        this.id = id;
+        this.metrics = metrics;
+        this.handlers = handlers;
+        this.testName = testName;
+        this.globalThinkTime = globalThinkTime; // Store global think time
+        this.stepExecutor = new step_executor_1.StepExecutor(handlers, testName); // Pass testName to StepExecutor
+        this.vuHooksManager = new hooks_manager_1.VUHooksManager(testName, id, vuHooks);
+        // Initialize global CSV if configured
+        if (globalCSV?.config) {
+            this.globalCSVMode = globalCSV.mode || 'next';
+            this.globalCSVProvider = csv_data_provider_1.CSVDataProvider.getInstance(globalCSV.config);
+            logger_1.logger.debug(`VU${id}: Global CSV configured (mode: ${this.globalCSVMode})`);
+        }
+        this.context = {
+            vu_id: id,
+            iteration: 0,
+            variables: {},
+            extracted_data: {}
+            // csv_data and global_csv_data will be added only when needed
+        };
+    }
+    // FIXED: Now async to support CSV initialization
+    async setScenarios(scenarios) {
+        logger_1.logger.debug(`VU${this.id}: setScenarios called with ${scenarios.length} scenarios`);
+        this.scenarios = scenarios;
+        // Debug: Let's see what the scenarios look like
+        for (const scenario of scenarios) {
+            logger_1.logger.debug(`VU${this.id}: Scenario "${scenario.name}" config: ${JSON.stringify(scenario, null, 2)}`);
+        }
+        // Initialize CSV providers only if needed
+        await this.initializeCSVProvidersIfNeeded();
+        logger_1.logger.debug(`VU${this.id}: setScenarios completed`);
+    }
+    /**
+     * Initialize CSV providers only for scenarios that need them
+     */
+    async initializeCSVProvidersIfNeeded() {
+        const csvScenarios = this.scenarios.filter(s => s.csv_data);
+        if (csvScenarios.length === 0) {
+            // No CSV scenarios - skip initialization entirely
+            logger_1.logger.debug(`VU${this.id}: No CSV scenarios found, skipping CSV initialization`);
+            return;
+        }
+        logger_1.logger.debug(`VU${this.id}: Found ${csvScenarios.length} scenarios with CSV data`);
+        for (const scenario of csvScenarios) {
+            const csvScenario = scenario; // Cast to access CSV properties
+            logger_1.logger.debug(`VU${this.id}: Processing CSV for scenario "${scenario.name}": ${JSON.stringify(csvScenario.csv_data)}`);
+            if (csvScenario.csv_data) {
+                try {
+                    const provider = csv_data_provider_1.CSVDataProvider.getInstance(csvScenario.csv_data);
+                    await provider.loadData();
+                    this.csvProviders.set(scenario.name, provider);
+                    logger_1.logger.debug(`VU${this.id}: Initialized CSV provider for scenario "${scenario.name}"`);
+                }
+                catch (error) {
+                    logger_1.logger.warn(`VU${this.id}: Failed to initialize CSV for scenario "${scenario.name}":`, error);
+                    // Don't fail the entire VU - just log the warning and continue
+                }
+            }
+        }
+        logger_1.logger.debug(`VU${this.id}: CSV initialization completed. Providers: ${this.csvProviders.size}`);
+    }
+    /**
+     * Load global CSV data and merge into context variables
+     * Called once at the start of each VU execution cycle
+     */
+    async loadGlobalCSVData() {
+        if (!this.globalCSVProvider) {
+            return;
+        }
+        try {
+            await this.globalCSVProvider.loadData();
+            let csvData = null;
+            switch (this.globalCSVMode) {
+                case 'unique':
+                    csvData = await this.globalCSVProvider.getUniqueRow(this.id);
+                    break;
+                case 'random':
+                    csvData = await this.globalCSVProvider.getRandomRow(this.id);
+                    break;
+                case 'next':
+                default:
+                    csvData = await this.globalCSVProvider.getNextRow(this.id);
+                    break;
+            }
+            if (csvData) {
+                this.context.global_csv_data = csvData;
+                // Merge global CSV data into variables (can be overridden by scenario CSV)
+                logger_1.logger.debug(`VU${this.id}: Adding global CSV columns to variables: ${Object.keys(csvData).join(', ')}`);
+                for (const [key, value] of Object.entries(csvData)) {
+                    this.context.variables[key] = value;
+                    logger_1.logger.debug(`VU${this.id}: Set global CSV variable: ${key} = ${value}`);
+                }
+                logger_1.logger.debug(`VU ${this.id}: Loaded global CSV data: ${Object.keys(csvData).join(', ')}`);
+            }
+            else {
+                logger_1.logger.debug(`VU${this.id}: Global CSV data exhausted - stopping VU`);
+                delete this.context.global_csv_data;
+                await this.stop();
+                throw new Error(`VU${this.id} terminated due to global CSV data exhaustion`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('terminated due to global CSV')) {
+                throw error;
+            }
+            logger_1.logger.warn(`📊 VU ${this.id}: Failed to load global CSV data:`, error);
+            delete this.context.global_csv_data;
+        }
+    }
+    // This method executes scenarios once (called repeatedly by load patterns)
+    async executeScenarios() {
+        if (!this.isActive || this.scenarios.length === 0) {
+            return;
+        }
+        // Load global CSV data first (available to all scenarios)
+        try {
+            await this.loadGlobalCSVData();
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('terminated due to global CSV')) {
+                logger_1.logger.warn(`📊 VU ${this.id}: Stopping due to global CSV exhaustion`);
+                return;
+            }
+            // Log but continue if global CSV fails for other reasons
+            logger_1.logger.warn(`📊 VU ${this.id}: Global CSV loading failed, continuing without:`, error);
+        }
+        // Execute beforeVU hook
+        try {
+            const beforeVUResult = await this.vuHooksManager.executeBeforeVU(this.context.variables, this.context.extracted_data);
+            // Merge any variables returned by beforeVU hook
+            if (beforeVUResult?.variables) {
+                Object.assign(this.context.variables, beforeVUResult.variables);
+                logger_1.logger.debug(`VU${this.id}: beforeVU hook set variables: ${Object.keys(beforeVUResult.variables).join(', ')}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ VU ${this.id} beforeVU hook failed:`, error);
+            // Continue execution even if beforeVU fails
+        }
+        try {
+            const selectedScenarios = this.selectScenarios(this.scenarios);
+            for (const scenario of selectedScenarios) {
+                if (!this.isActive)
+                    break;
+                try {
+                    await this.executeScenario(scenario);
+                }
+                catch (error) {
+                    logger_1.logger.error(`❌ VU ${this.id} failed executing scenario ${scenario.name}:`, error);
+                    this.metrics.recordError(this.id, scenario.name, 'scenario', error);
+                }
+            }
+        }
+        finally {
+            // Execute teardownVU hook
+            try {
+                await this.vuHooksManager.executeTeardownVU(this.context.variables, this.context.extracted_data);
+            }
+            catch (error) {
+                logger_1.logger.error(`❌ VU ${this.id} teardownVU hook failed:`, error);
+            }
+        }
+    }
+    async executeScenario(scenario) {
+        // Handle both number and LoopConfig for backwards compatibility
+        const loops = typeof scenario.loop === 'number' ? scenario.loop : (scenario.loop?.count || 1);
+        logger_1.logger.debug(`VU ${this.id} executing scenario: ${scenario.name} (${loops} loops)`);
+        logger_1.logger.debug(`Scenario variables: ${JSON.stringify(scenario.variables)}`);
+        // Process scenario variables and store in context
+        if (scenario.variables) {
+            logger_1.logger.debug(`Processing ${Object.keys(scenario.variables).length} scenario variables`);
+            for (const [key, value] of Object.entries(scenario.variables)) {
+                this.context.variables[key] = value;
+                logger_1.logger.debug(`Set variable: ${key} = ${value}`);
+            }
+        }
+        // Load CSV data if this scenario uses it (completely optional)
+        logger_1.logger.debug(`About to load CSV data if needed...`);
+        await this.loadCSVDataIfNeeded(scenario);
+        logger_1.logger.debug(`CSV data loading completed`);
+        logger_1.logger.debug(`Context variables after CSV setup: ${JSON.stringify(this.context.variables)}`);
+        // Create scenario hooks manager
+        const scenarioHooksManager = new hooks_manager_1.ScenarioHooksManager(this.testName, this.id, scenario.name, scenario.hooks);
+        // Execute beforeScenario hook
+        try {
+            const beforeScenarioResult = await scenarioHooksManager.executeBeforeScenario(this.context.variables, this.context.extracted_data, this.context.csv_data);
+            // CRITICAL FIX: The hook manager should have updated the objects by reference
+            // But let's also merge any returned variables to be safe
+            if (beforeScenarioResult?.variables) {
+                Object.assign(this.context.variables, beforeScenarioResult.variables);
+                logger_1.logger.debug(`VU${this.id}: beforeScenario hook merged additional variables: ${Object.keys(beforeScenarioResult.variables).join(', ')}`);
+            }
+            // Debug: Show what's in context after beforeScenario
+            logger_1.logger.debug(`VU${this.id}: Variables after beforeScenario: ${Object.keys(this.context.variables).join(', ')}`);
+            logger_1.logger.debug(`VU${this.id}: Extracted data after beforeScenario: ${Object.keys(this.context.extracted_data).join(', ')}`);
+            logger_1.logger.debug(`VU${this.id}: Extracted data values: ${JSON.stringify(this.context.extracted_data)}`);
+        }
+        catch (error) {
+            logger_1.logger.error(`❌ VU ${this.id} beforeScenario hook failed:`, error);
+            // You might want to return here if authentication is critical
+            if (scenario.hooks?.beforeScenario?.continueOnError === false) {
+                throw error;
+            }
+        }
+        // Legacy support: Run setup if configured (deprecated - use hooks.beforeScenario)
+        if (scenario.setup && !scenario.hooks?.beforeScenario) {
+            await this.executeSetup(scenario.setup);
+        }
+        try {
+            for (let iteration = 0; iteration < loops; iteration++) {
+                if (!this.isActive)
+                    break;
+                this.context.iteration = iteration;
+                logger_1.logger.debug(`🔁 VU ${this.id} scenario ${scenario.name} iteration ${iteration + 1}/${loops}`);
+                // Execute beforeLoop hook
+                try {
+                    const beforeLoopResult = await scenarioHooksManager.executeBeforeLoop(iteration, this.context.variables, this.context.extracted_data, this.context.csv_data);
+                    if (beforeLoopResult?.variables) {
+                        Object.assign(this.context.variables, beforeLoopResult.variables);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error(`❌ VU ${this.id} beforeLoop hook failed:`, error);
+                }
+                // For unique CSV mode, get new CSV data each iteration
+                const csvScenario = scenario;
+                if (csvScenario.csv_mode === 'unique' && iteration > 0 && this.csvProviders.has(scenario.name)) {
+                    await this.loadCSVDataIfNeeded(scenario);
+                }
+                try {
+                    // Execute all steps in sequence
+                    for (let stepIndex = 0; stepIndex < scenario.steps.length; stepIndex++) {
+                        if (!this.isActive)
+                            break;
+                        const step = scenario.steps[stepIndex];
+                        // Debug: Show context before each step
+                        logger_1.logger.debug(`VU${this.id}: About to execute step "${step.name || step.type}"`);
+                        logger_1.logger.debug(`VU${this.id}: Available variables: ${Object.keys(this.context.variables).join(', ')}`);
+                        logger_1.logger.debug(`VU${this.id}: Available extracted_data: ${Object.keys(this.context.extracted_data).join(', ')}`);
+                        try {
+                            const result = await this.stepExecutor.executeStep(step, this.context, scenario.name);
+                            if (result.shouldRecord) {
+                                this.metrics.recordResult(result);
+                            }
+                            // Apply hierarchical think time: step > scenario > global
+                            const effectiveThinkTime = this.getEffectiveThinkTime(step, scenario);
+                            if (effectiveThinkTime !== undefined) {
+                                await this.applyThinkTime(effectiveThinkTime);
+                            }
+                        }
+                        catch (error) {
+                            logger_1.logger.error(`❌ VU ${this.id} step failed:`, error);
+                            this.metrics.recordError(this.id, scenario.name, step.name || step.type || 'rest', error);
+                        }
+                    }
+                    // Execute afterLoop hook
+                    try {
+                        await scenarioHooksManager.executeAfterLoop(iteration, this.context.variables, this.context.extracted_data, this.context.csv_data);
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`❌ VU ${this.id} afterLoop hook failed:`, error);
+                    }
+                }
+                catch (error) {
+                    // Execute afterLoop hook even on error
+                    try {
+                        await scenarioHooksManager.executeAfterLoop(iteration, this.context.variables, this.context.extracted_data, this.context.csv_data);
+                    }
+                    catch (hookError) {
+                        logger_1.logger.error(`❌ VU ${this.id} afterLoop hook failed during error handling:`, hookError);
+                    }
+                    throw error;
+                }
+                // Think time between iterations (except after last iteration)
+                if (iteration < loops - 1) {
+                    await this.applyThinkTime(scenario.think_time);
+                }
+            }
+        }
+        finally {
+            // Execute teardownScenario hook
+            try {
+                await scenarioHooksManager.executeTeardownScenario(this.context.variables, this.context.extracted_data, this.context.csv_data);
+            }
+            catch (error) {
+                logger_1.logger.error(`❌ VU ${this.id} teardownScenario hook failed:`, error);
+            }
+            // Legacy support: Run teardown if configured (deprecated - use hooks.teardownScenario)
+            if (scenario.teardown && !scenario.hooks?.teardownScenario) {
+                await this.executeTeardown(scenario.teardown);
+            }
+        }
+    }
+    // ... rest of your existing methods remain exactly the same
+    async loadCSVDataIfNeeded(scenario) {
+        const csvScenario = scenario;
+        logger_1.logger.debug(`VU${this.id}: Checking CSV need for scenario "${scenario.name}"`);
+        logger_1.logger.debug(`VU${this.id}: Has csv_data config: ${!!csvScenario.csv_data}`);
+        logger_1.logger.debug(`VU${this.id}: Has CSV provider: ${this.csvProviders.has(scenario.name)}`);
+        if (!csvScenario.csv_data || !this.csvProviders.has(scenario.name)) {
+            logger_1.logger.debug(`VU${this.id}: No CSV data needed for scenario "${scenario.name}"`);
+            delete this.context.csv_data;
+            return;
+        }
+        try {
+            logger_1.logger.debug(`VU${this.id}: Loading CSV data for scenario "${scenario.name}"...`);
+            const csvData = await this.loadCSVDataForScenario(csvScenario);
+            if (csvData) {
+                this.context.csv_data = csvData;
+                logger_1.logger.debug(`VU${this.id}: Adding CSV columns to variables: ${Object.keys(csvData).join(', ')}`);
+                for (const [key, value] of Object.entries(csvData)) {
+                    if (!(key in this.context.variables)) {
+                        this.context.variables[key] = value;
+                        logger_1.logger.debug(`VU${this.id}: Added CSV variable: ${key} = ${value}`);
+                    }
+                    else {
+                        logger_1.logger.debug(`VU${this.id}: Skipped CSV variable ${key} (already in variables)`);
+                    }
+                }
+                logger_1.logger.debug(`VU ${this.id}: Loaded CSV data for scenario "${scenario.name}": ${Object.keys(csvData).join(', ')}`);
+            }
+            else {
+                logger_1.logger.debug(`VU${this.id}: No CSV data available - terminating this VU`);
+                delete this.context.csv_data;
+                this.stop();
+                throw new Error(`VU${this.id} terminated due to CSV data exhaustion in scenario "${scenario.name}"`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('terminated due to CSV data exhaustion')) {
+                throw error;
+            }
+            logger_1.logger.warn(`VU ${this.id}: Failed to load CSV data for scenario "${scenario.name}":`, error);
+            delete this.context.csv_data;
+            logger_1.logger.debug(`VU${this.id}: Continuing with fallback variables after CSV error`);
+        }
+    }
+    async loadCSVDataForScenario(scenario) {
+        const provider = this.csvProviders.get(scenario.name);
+        if (!provider) {
+            return null;
+        }
+        const mode = scenario.csv_mode || 'next';
+        switch (mode) {
+            case 'unique':
+                return await provider.getUniqueRow(this.id);
+            case 'random':
+                return await provider.getRandomRow();
+            case 'next':
+            default:
+                return await provider.getNextRow(this.id);
+        }
+    }
+    selectScenarios(scenarios) {
+        const selected = [];
+        for (const scenario of scenarios) {
+            const weight = scenario.weight || 100;
+            const random = Math.random() * 100;
+            if (random < weight) {
+                selected.push(scenario);
+            }
+        }
+        // Ensure at least one scenario is selected
+        if (selected.length === 0 && scenarios.length > 0) {
+            selected.push(scenarios[0]);
+        }
+        return selected;
+    }
+    async executeSetup(setupScript) {
+        try {
+            await this.executeScript(setupScript, 'setup');
+        }
+        catch (error) {
+            logger_1.logger.warn(`⚠️ VU ${this.id} setup script failed:`, error);
+        }
+    }
+    async executeTeardown(teardownScript) {
+        try {
+            await this.executeScript(teardownScript, 'teardown');
+        }
+        catch (error) {
+            logger_1.logger.warn(`⚠️ VU ${this.id} teardown script failed:`, error);
+        }
+    }
+    async executeScript(script, type) {
+        const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+        const fn = new AsyncFunction('context', 'require', 'console', script);
+        const timeout = 30000; // 30 seconds timeout
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`${type} script timeout`)), timeout);
+        });
+        return Promise.race([
+            fn(this.context, require, console),
+            timeoutPromise
+        ]);
+    }
+    /**
+     * Get effective think time using hierarchical override:
+     * Step think_time > Scenario think_time > Global think_time
+     */
+    getEffectiveThinkTime(step, scenario) {
+        // Step level has highest priority
+        if (step.think_time !== undefined) {
+            return step.think_time;
+        }
+        // Scenario level is next
+        if (scenario.think_time !== undefined) {
+            return scenario.think_time;
+        }
+        // Global level is fallback
+        return this.globalThinkTime;
+    }
+    async applyThinkTime(thinkTime) {
+        if (!thinkTime) {
+            // No think time specified at any level - skip
+            return;
+        }
+        if (typeof thinkTime === 'number') {
+            logger_1.logger.debug(`Applying thinktime: ${thinkTime} seconds`);
+            await (0, time_1.sleep)(thinkTime * 1000);
+            return;
+        }
+        const rangeMatch = thinkTime.match(/^(\d+(?:\.\d+)?)-(\d+(?:\.\d+)?)([sm])?$/);
+        if (rangeMatch) {
+            const [, minStr, maxStr, unit] = rangeMatch;
+            let min = parseFloat(minStr);
+            let max = parseFloat(maxStr);
+            if (unit === 's' || !unit) {
+                min *= 1000;
+                max *= 1000;
+            }
+            const thinkTimeMs = (0, time_1.randomBetween)(min, max);
+            await (0, time_1.sleep)(thinkTimeMs);
+        }
+        else {
+            try {
+                const thinkTimeMs = (0, time_1.parseTime)(thinkTime);
+                await (0, time_1.sleep)(thinkTimeMs);
+            }
+            catch (error) {
+                logger_1.logger.warn(`⚠️ Invalid think time format: ${thinkTime}`);
+                await (0, time_1.sleep)((0, time_1.randomBetween)(1000, 3000));
+            }
+        }
+    }
+    // stop(): void {
+    //   this.isActive = false;
+    //   logger.debug(`⏹️ VU ${this.id} stopped`);
+    // }
+    async stop() {
+        this.isActive = false;
+        logger_1.logger.debug(`⏹️ VU ${this.id} stopping...`);
+        // Clean up browser resources if WebHandler exists
+        const webHandler = this.handlers.get('web');
+        if (webHandler && typeof webHandler.cleanupVU === 'function') {
+            try {
+                await webHandler.cleanupVU(this.id);
+                logger_1.logger.debug(`🧹 VU ${this.id}: Browser cleanup completed`);
+            }
+            catch (error) {
+                logger_1.logger.warn(`⚠️ VU ${this.id}: Error during browser cleanup:`, error);
+            }
+        }
+        logger_1.logger.debug(`⏹️ VU ${this.id} stopped`);
+    }
+    getId() {
+        return this.id;
+    }
+    isRunning() {
+        return this.isActive;
+    }
+}
+exports.VirtualUser = VirtualUser;

package/dist/distributed/coordinator.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter } from 'events';
+import { TestConfiguration } from '../config';
+import { RemoteWorker, RemoteWorkerConfig } from './remote-worker';
+export interface DistributedTestConfig {
+    workers: RemoteWorkerConfig[];
+    strategy: 'even' | 'capacity_based' | 'round_robin' | 'geographic';
+    sync_start: boolean;
+    heartbeat_interval: number;
+    timeout: number;
+    retry_failed: boolean;
+}
+export interface WorkAssignment {
+    worker: RemoteWorker;
+    config: TestConfiguration;
+    virtualUsers: number;
+}
+export declare class DistributedCoordinator extends EventEmitter {
+    private workers;
+    private config;
+    private testConfig;
+    private loadDistributor;
+    private resultAggregator;
+    private healthMonitor;
+    private isRunning;
+    constructor(config: DistributedTestConfig);
+    initialize(): Promise<void>;
+    executeTest(testConfig: TestConfiguration): Promise<void>;
+    private synchronizedStart;
+    private rollingStart;
+    private waitForCompletion;
+    stop(): Promise<void>;
+    cleanup(): Promise<void>;
+    getAggregatedResults(): any;
+}

package/dist/distributed/coordinator.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedCoordinator = void 0;
+const events_1 = require("events");
+const remote_worker_1 = require("./remote-worker"); // Fixed import
+const load_distributor_1 = require("./load-distributor");
+const result_aggregator_1 = require("./result-aggregator");
+const health_monitor_1 = require("./health-monitor");
+const logger_1 = require("../utils/logger");
+class DistributedCoordinator extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.workers = [];
+        this.testConfig = null;
+        this.isRunning = false;
+        this.config = config;
+        this.loadDistributor = new load_distributor_1.LoadDistributor();
+        this.resultAggregator = new result_aggregator_1.ResultAggregator();
+        this.healthMonitor = new health_monitor_1.HealthMonitor();
+    }
+    async initialize() {
+        logger_1.logger.info(`🌍 Initializing distributed test with ${this.config.workers.length} workers`);
+        for (const workerConfig of this.config.workers) {
+            try {
+                const worker = new remote_worker_1.RemoteWorker(workerConfig);
+                worker.on('result', (result) => {
+                    this.resultAggregator.addResult(result);
+                    this.emit('result', result);
+                });
+                worker.on('error', (error) => {
+                    logger_1.logger.error(`❌ Worker ${worker.getAddress()} error:`, error);
+                    this.emit('worker-error', { worker: worker.getAddress(), error });
+                });
+                worker.on('status', (status) => {
+                    this.healthMonitor.updateWorkerStatus(worker.getAddress(), status);
+                });
+                await worker.connect();
+                this.workers.push(worker);
+                logger_1.logger.info(`✅ Connected to worker: ${worker.getAddress()}`);
+            }
+            catch (error) {
+                logger_1.logger.error(`❌ Failed to connect to worker ${workerConfig.host}:${workerConfig.port}:`, error);
+                if (!this.config.retry_failed) {
+                    throw error;
+                }
+            }
+        }
+        if (this.workers.length === 0) {
+            throw new Error('No workers available for distributed testing');
+        }
+        this.healthMonitor.start(this.workers, this.config.heartbeat_interval);
+        logger_1.logger.info(`🎯 ${this.workers.length} workers ready for distributed testing`);
+    }
+    async executeTest(testConfig) {
+        this.testConfig = testConfig;
+        this.isRunning = true;
+        try {
+            const workAssignments = this.loadDistributor.distribute(testConfig, this.workers, this.config.strategy);
+            logger_1.logger.info(`📊 Load distribution:`);
+            workAssignments.forEach(assignment => {
+                logger_1.logger.info(`   ${assignment.worker.getAddress()}: ${assignment.virtualUsers} VUs`);
+            });
+            this.resultAggregator.start();
+            if (this.config.sync_start) {
+                await this.synchronizedStart(workAssignments);
+            }
+            else {
+                await this.rollingStart(workAssignments);
+            }
+            await this.waitForCompletion();
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    async synchronizedStart(assignments) {
+        logger_1.logger.info('🚀 Starting synchronized distributed test...');
+        const preparations = assignments.map(async (assignment) => {
+            await assignment.worker.prepareTest(assignment.config);
+        });
+        await Promise.all(preparations);
+        logger_1.logger.info('✅ All workers prepared');
+        const startTime = Date.now() + 5000;
+        const starts = assignments.map(async (assignment) => {
+            await assignment.worker.startTest(startTime);
+        });
+        await Promise.all(starts);
+        logger_1.logger.info('🎯 All workers started');
+    }
+    async rollingStart(assignments) {
+        logger_1.logger.info('🔄 Starting rolling distributed test...');
+        for (const assignment of assignments) {
+            try {
+                await assignment.worker.executeTest(assignment.config);
+                logger_1.logger.info(`✅ Started worker ${assignment.worker.getAddress()}`);
+            }
+            catch (error) {
+                logger_1.logger.error(`❌ Failed to start worker ${assignment.worker.getAddress()}:`, error);
+            }
+        }
+    }
+    async waitForCompletion() {
+        logger_1.logger.info('⏳ Waiting for all workers to complete...');
+        const completionPromises = this.workers.map(worker => worker.waitForCompletion().catch((error) => {
+            logger_1.logger.error(`❌ Worker ${worker.getAddress()} completion error:`, error);
+            return null;
+        }));
+        await Promise.all(completionPromises);
+        // Collect results from all workers
+        logger_1.logger.info('📊 Collecting results from workers...');
+        for (const worker of this.workers) {
+            try {
+                const workerResults = await worker.getResults();
+                if (workerResults) {
+                    // Add worker results to aggregator
+                    if (workerResults.results) {
+                        workerResults.results.forEach((result) => {
+                            this.resultAggregator.addResult(result, worker.getAddress());
+                        });
+                    }
+                    // Add VU ramp-up events from worker's summary
+                    if (workerResults.summary?.vu_ramp_up && Array.isArray(workerResults.summary.vu_ramp_up)) {
+                        this.resultAggregator.addVURampUpEvents(workerResults.summary.vu_ramp_up, worker.getAddress());
+                        logger_1.logger.debug(`📊 Collected ${workerResults.summary.vu_ramp_up.length} VU events from ${worker.getAddress()}`);
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn(`⚠️ Failed to get results from worker ${worker.getAddress()}:`, error);
+            }
+        }
+        this.resultAggregator.stop();
+        logger_1.logger.info('✅ All workers completed');
+    }
+    async stop() {
+        logger_1.logger.info('⏹️  Stopping distributed test...');
+        this.isRunning = false;
+        const stopPromises = this.workers.map(worker => worker.stop().catch((error) => {
+            logger_1.logger.warn(`⚠️  Error stopping worker ${worker.getAddress()}:`, error);
+        }));
+        await Promise.all(stopPromises);
+        logger_1.logger.info('🛑 All workers stopped');
+    }
+    async cleanup() {
+        logger_1.logger.info('🧹 Cleaning up distributed test...');
+        this.healthMonitor.stop();
+        const cleanupPromises = this.workers.map(worker => worker.disconnect().catch((error) => {
+            logger_1.logger.warn(`⚠️  Error cleaning up worker ${worker.getAddress()}:`, error);
+        }));
+        await Promise.all(cleanupPromises);
+        this.workers = [];
+        logger_1.logger.info('✅ Cleanup completed');
+    }
+    getAggregatedResults() {
+        return this.resultAggregator.getAggregatedResults();
+    }
+}
+exports.DistributedCoordinator = DistributedCoordinator;