@testsmith/perfornium 0.6.4 → 0.6.5

package/dist/core/test-runner.js

@@ -36,23 +36,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestRunner = void 0;
 const collector_1 = require("../metrics/collector");
 const virtual_user_1 = require("./virtual-user");
-const handler_1 = require("../protocols/rest/handler");
-const handler_2 = require("../protocols/soap/handler");
-const handler_3 = require("../protocols/web/handler");
+const data_1 = require("./data");
 const basic_1 = require("../load-patterns/basic");
 const stepping_1 = require("../load-patterns/stepping");
 const arrivals_1 = require("../load-patterns/arrivals");
-const csv_1 = require("../outputs/csv");
-const json_1 = require("../outputs/json");
-const influxdb_1 = require("../outputs/influxdb");
-const graphite_1 = require("../outputs/graphite");
-const webhook_1 = require("../outputs/webhook");
 const logger_1 = require("../utils/logger");
 const time_1 = require("../utils/time");
-const csv_data_provider_1 = require("./csv-data-provider");
 const rendezvous_1 = require("./rendezvous");
 const file_manager_1 = require("../utils/file-manager");
-const dashboard_1 = require("../dashboard");
+const protocol_handler_factory_1 = require("./factories/protocol-handler-factory");
+const output_handler_factory_1 = require("./factories/output-handler-factory");
+const dashboard_reporter_1 = require("./reporting/dashboard-reporter");
 class TestRunner {
     constructor(config) {
         this.handlers = new Map();
@@ -61,10 +55,32 @@ class TestRunner {
         this.isRunning = false;
         this.startTime = 0;
         this.testId = '';
-        this.dashboardInterval = null;
-        this.lastReportedResultIndex = 0;
+        this.dashboardReporter = null;
         this.config = config;
-        this.metrics = new collector_1.MetricsCollector();
+        // Build realtime config including InfluxDB settings
+        const realtimeConfig = {
+            enabled: true,
+            batch_size: 10,
+            incremental_files: {
+                enabled: true
+            }
+        };
+        // Add InfluxDB config if enabled in global config
+        if (config.global?.influxdb?.enabled) {
+            realtimeConfig.influxdb = {
+                enabled: true,
+                url: config.global.influxdb.url,
+                token: config.global.influxdb.token,
+                org: config.global.influxdb.org,
+                bucket: config.global.influxdb.bucket,
+                batch_size: config.global.influxdb.batch_size,
+                flush_interval: config.global.influxdb.flush_interval
+            };
+        }
+        this.metrics = new collector_1.MetricsCollector(realtimeConfig);
+        // Initialize factories (pass metrics collector for network call recording)
+        this.protocolHandlerFactory = new protocol_handler_factory_1.ProtocolHandlerFactory(config, this.metrics);
+        this.outputHandlerFactory = new output_handler_factory_1.OutputHandlerFactory(config.name);
         // Set log level based on debug config
         if (config.debug?.log_level || config.global?.debug?.log_level) {
             const logLevel = config.debug?.log_level || config.global?.debug?.log_level;
@@ -85,24 +101,23 @@ class TestRunner {
         }
     }
     async run() {
-        logger_1.logger.info(`🚀 Starting test: ${this.config.name}`);
+        logger_1.logger.info(`Starting test: ${this.config.name}`);
         this.isRunning = true;
         this.startTime = Date.now();
         this.testId = `test-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Reset rendezvous manager for this test run
         rendezvous_1.RendezvousManager.getInstance().reset();
-        // Start dashboard reporting if dashboard is running
+        // Start dashboard reporting
         this.startDashboardReporting();
         try {
             await this.initialize();
-            // NO CSV termination callback setup needed anymore
             await this.executeLoadPattern();
             await this.finalize();
             const duration = Date.now() - this.startTime;
-            logger_1.logger.success(`✅ Test completed successfully in ${(duration / 1000).toFixed(1)}s`);
+            logger_1.logger.success(`Test completed successfully in ${(duration / 1000).toFixed(1)}s`);
         }
         catch (error) {
-            logger_1.logger.error('❌ Test failed:', error);
+            logger_1.logger.error('Test failed:', error);
             throw error;
         }
         finally {
@@ -111,282 +126,65 @@ class TestRunner {
         }
     }
     startDashboardReporting() {
-        const dashboard = (0, dashboard_1.getDashboard)();
-        // If running standalone (no dashboard singleton), output progress to stdout for dashboard parsing
-        const outputProgress = !dashboard && process.env.PERFORNIUM_PROGRESS !== '0';
-        if (dashboard) {
-            // Report initial state to in-process dashboard
-            dashboard.reportLiveUpdate(this.testId, {
-                id: this.testId,
-                name: this.config.name,
-                startTime: new Date(),
-                status: 'running',
-                metrics: {
-                    requests: 0,
-                    errors: 0,
-                    avgResponseTime: 0,
-                    currentVUs: 0
-                }
-            });
-        }
-        // Track last request count to detect activity
-        let lastRequestCount = 0;
-        // Report updates every 500ms
-        this.dashboardInterval = setInterval(() => {
-            if (!this.isRunning)
-                return;
-            const summary = this.metrics.getSummary();
-            const currentVUs = this.activeVUs.filter(vu => vu.isRunning()).length;
-            const currentRequests = summary.total_requests || 0;
-            // Skip reporting if VUs are 0 and no new requests (test is winding down)
-            const hasActivity = currentVUs > 0 || currentRequests > lastRequestCount;
-            lastRequestCount = currentRequests;
-            if (dashboard) {
-                dashboard.reportLiveUpdate(this.testId, {
-                    metrics: {
-                        requests: currentRequests,
-                        errors: summary.failed_requests || 0,
-                        avgResponseTime: summary.avg_response_time || 0,
-                        currentVUs
-                    }
-                });
-            }
-            // Output machine-readable progress for dashboard parsing (only when there's activity)
-            if (outputProgress && hasActivity) {
-                const rps = summary.requests_per_second || 0;
-                const p50 = summary.percentiles?.[50] || 0;
-                const p90 = summary.percentiles?.[90] || 0;
-                const p95 = summary.percentiles?.[95] || 0;
-                const p99 = summary.percentiles?.[99] || 0;
-                const successRate = summary.success_rate || 0;
-                // Main progress line with percentiles
-                console.log(`[PROGRESS] VUs: ${currentVUs} | Requests: ${currentRequests} | Errors: ${summary.failed_requests || 0} | Avg RT: ${(summary.avg_response_time || 0).toFixed(0)}ms | RPS: ${rps.toFixed(1)} | P50: ${p50.toFixed(0)}ms | P90: ${p90.toFixed(0)}ms | P95: ${p95.toFixed(0)}ms | P99: ${p99.toFixed(0)}ms | Success: ${successRate.toFixed(1)}%`);
-                // Output step statistics if available
-                if (summary.step_statistics && summary.step_statistics.length > 0) {
-                    const stepData = summary.step_statistics.map(s => ({
-                        n: s.step_name,
-                        s: s.scenario,
-                        r: s.total_requests,
-                        e: s.failed_requests,
-                        a: Math.round(s.avg_response_time),
-                        p50: Math.round(s.percentiles?.[50] || 0),
-                        p95: Math.round(s.percentiles?.[95] || 0),
-                        p99: Math.round(s.percentiles?.[99] || 0),
-                        sr: Math.round(s.success_rate * 10) / 10
-                    }));
-                    console.log(`[STEPS] ${JSON.stringify(stepData)}`);
-                }
-                // Output individual response times (last 50 new results)
-                const allResults = this.metrics.getResults();
-                if (allResults.length > this.lastReportedResultIndex) {
-                    const newResults = allResults.slice(this.lastReportedResultIndex, this.lastReportedResultIndex + 50);
-                    const rtData = newResults.map(r => ({
-                        t: r.timestamp,
-                        v: Math.round(r.duration),
-                        s: r.success ? 1 : 0,
-                        n: r.step_name || r.action || 'unknown' // Include step/request name for coloring
-                    }));
-                    if (rtData.length > 0) {
-                        console.log(`[RT] ${JSON.stringify(rtData)}`);
-                    }
-                    this.lastReportedResultIndex = Math.min(allResults.length, this.lastReportedResultIndex + 50);
-                }
-                // Output top 10 errors if any
-                if (summary.error_details && summary.error_details.length > 0) {
-                    const topErrors = summary.error_details.slice(0, 10).map((e) => ({
-                        scenario: e.scenario,
-                        action: e.action,
-                        status: e.status,
-                        error: e.error?.substring(0, 200),
-                        url: e.request_url,
-                        count: e.count
-                    }));
-                    console.log(`[ERRORS] ${JSON.stringify(topErrors)}`);
-                }
-            }
-        }, 500);
+        this.dashboardReporter = new dashboard_reporter_1.DashboardReporter({
+            testId: this.testId,
+            testName: this.config.name
+        });
+        this.dashboardReporter.start(this.metrics, () => this.activeVUs, () => this.isRunning);
     }
     stopDashboardReporting() {
-        if (this.dashboardInterval) {
-            clearInterval(this.dashboardInterval);
-            this.dashboardInterval = null;
-        }
-        const dashboard = (0, dashboard_1.getDashboard)();
-        if (dashboard) {
-            dashboard.reportTestComplete(this.testId);
+        if (this.dashboardReporter) {
+            this.dashboardReporter.stop();
+            this.dashboardReporter = null;
         }
     }
     setupCSVBaseDirectory() {
         const hasCSVScenarios = this.config.scenarios?.some((s) => s.csv_data);
         if (hasCSVScenarios) {
             const baseDir = process.cwd();
-            csv_data_provider_1.CSVDataProvider.setBaseDir(baseDir);
-            // Check if any scenario has cycleOnExhaustion: false
+            data_1.DataProvider.setBaseDir(baseDir);
             const hasStopOnExhaustion = this.config.scenarios?.some((s) => s.csv_data && s.csv_data.cycleOnExhaustion === false);
             if (hasStopOnExhaustion) {
-                logger_1.logger.info('⏹️ CSV exhaustion handling enabled - individual VUs will stop when CSV data is exhausted');
+                logger_1.logger.info('CSV exhaustion handling enabled - individual VUs will stop when CSV data is exhausted');
             }
             logger_1.logger.debug(`Set CSV base directory: ${baseDir}`);
         }
     }
-    // FIXED: Added stop method that was missing
     async stop() {
-        logger_1.logger.info('⏹️  Stopping test...');
+        logger_1.logger.info('Stopping test...');
         this.isRunning = false;
         // Stop rendezvous manager - releases any waiting VUs
         rendezvous_1.RendezvousManager.getInstance().stop();
         // Stop all active VUs
         this.activeVUs.forEach(vu => vu.stop());
         // Wait for VUs to finish current operations
-        await this.waitForVUsToComplete(10000); // 10 second timeout
+        await this.waitForVUsToComplete(10000);
+        // Finalize metrics (stops batch processor timers)
+        await this.metrics.finalize();
         // Cleanup handlers
-        await this.cleanup();
+        await protocol_handler_factory_1.ProtocolHandlerFactory.cleanupHandlers(this.handlers);
+        // Generate summary and finalize outputs (ensures results files are properly closed)
+        const summary = this.metrics.getSummary();
+        await output_handler_factory_1.OutputHandlerFactory.finalizeOutputs(this.outputs, summary);
     }
     async initialize() {
-        logger_1.logger.debug('🔧 Initializing test runner...');
-        // Initialize protocol handlers
-        await this.initializeProtocolHandlers();
-        // Initialize outputs
-        await this.initializeOutputs();
-        // Setup metrics collection
-        this.metrics.start();
+        logger_1.logger.debug('Initializing test runner...');
+        // Initialize protocol handlers using factory
+        this.handlers = await this.protocolHandlerFactory.createHandlers();
+        // Initialize outputs using factory
+        this.outputs = await this.outputHandlerFactory.createOutputs(this.config.outputs);
+        // Initialize metrics collector (connects to InfluxDB if configured)
+        await this.metrics.initialize();
+        // Setup metrics collection with test name for InfluxDB tagging
+        this.metrics.start(this.config.name);
         this.metrics.on('result', (result) => {
             this.outputs.forEach(output => {
                 if (output && typeof output.writeResult === 'function') {
-                    output.writeResult(result).catch(err => logger_1.logger.warn('⚠️  Output write failed:', err));
+                    output.writeResult(result).catch(err => logger_1.logger.warn('Output write failed:', err));
                 }
             });
         });
-        logger_1.logger.debug('✅ Test runner initialized');
-    }
-    async initializeProtocolHandlers() {
-        // Check which protocols are needed based on scenarios
-        const protocolsNeeded = this.getRequiredProtocols();
-        const debugConfig = this.config.debug || this.config.global?.debug;
-        // Initialize REST handler if needed
-        if (protocolsNeeded.has('rest')) {
-            const handler = new handler_1.RESTHandler(this.config.global?.base_url, this.config.global?.headers || {}, this.config.global?.timeout, debugConfig // Pass debug config to handler
-            );
-            this.handlers.set('rest', handler);
-            logger_1.logger.debug('🌐 REST handler initialized');
-        }
-        // Initialize SOAP handler if needed
-        if (protocolsNeeded.has('soap')) {
-            const wsdlUrl = this.findWSDLUrl();
-            if (wsdlUrl) {
-                const handler = new handler_2.SOAPHandler(wsdlUrl);
-                await handler.initialize();
-                this.handlers.set('soap', handler);
-                logger_1.logger.debug('🧼 SOAP handler initialized');
-            }
-        }
-        // Initialize Web handler if needed
-        if (protocolsNeeded.has('web')) {
-            const browserConfig = this.config.global?.web || this.config.global?.browser || {};
-            const webConfig = {
-                type: browserConfig.type || 'chromium',
-                headless: browserConfig.headless ?? true,
-                base_url: browserConfig.base_url || this.config.global?.base_url,
-                viewport: browserConfig.viewport,
-                slow_mo: browserConfig.slow_mo,
-                highlight: browserConfig.highlight,
-                clear_storage: browserConfig.clear_storage,
-                screenshot_on_failure: browserConfig.screenshot_on_failure
-            };
-            const handler = new handler_3.WebHandler(webConfig);
-            await handler.initialize();
-            this.handlers.set('web', handler);
-            logger_1.logger.debug('🌐 Web handler initialized');
-        }
-    }
-    getRequiredProtocols() {
-        const protocols = new Set();
-        for (const scenario of this.config.scenarios) {
-            for (const step of scenario.steps) {
-                protocols.add(step.type || 'rest');
-            }
-        }
-        return protocols;
-    }
-    findWSDLUrl() {
-        // First check global config
-        if (this.config.global?.wsdl_url) {
-            return this.config.global.wsdl_url;
-        }
-        // Fallback: check individual steps (for backward compatibility)
-        for (const scenario of this.config.scenarios) {
-            for (const step of scenario.steps) {
-                if (step.type === 'soap' && 'wsdl' in step && step.wsdl) {
-                    return step.wsdl;
-                }
-            }
-        }
-        return null;
-    }
-    async initializeOutputs() {
-        if (!this.config.outputs)
-            return;
-        for (const outputConfig of this.config.outputs) {
-            // Skip disabled outputs
-            if (outputConfig.enabled === false) {
-                continue;
-            }
-            let output;
-            try {
-                // Process timestamp templates in file paths
-                const processedFilePath = this.processTemplateFilePath(outputConfig.file);
-                switch (outputConfig.type) {
-                    case 'csv':
-                        output = new csv_1.CSVOutput(processedFilePath);
-                        break;
-                    case 'json':
-                        output = new json_1.JSONOutput(processedFilePath);
-                        break;
-                    case 'influxdb':
-                        output = new influxdb_1.InfluxDBOutput(outputConfig.url, outputConfig.database, outputConfig.tags);
-                        break;
-                    case 'graphite':
-                        const [host, port] = (outputConfig.url || 'localhost:2003').split(':');
-                        output = new graphite_1.GraphiteOutput(host, parseInt(port || '2003'), 'perfornium');
-                        break;
-                    case 'webhook':
-                        output = new webhook_1.WebhookOutput(outputConfig.url, outputConfig.headers || {}, 'json', outputConfig.template);
-                        break;
-                    default:
-                        logger_1.logger.warn(`⚠️  Unsupported output type: ${outputConfig.type}`);
-                        continue;
-                }
-                await output.initialize();
-                this.outputs.push(output);
-                logger_1.logger.debug(`📊 ${outputConfig.type} output initialized`);
-            }
-            catch (error) {
-                logger_1.logger.warn(`⚠️  Failed to initialize ${outputConfig.type} output:`, error);
-            }
-        }
-    }
-    /**
-     * Process template variables in file paths and automatically add timestamp if not present
-     */
-    processTemplateFilePath(filePath) {
-        if (!filePath) {
-            return `results/${this.config.name}-{{timestamp}}.csv`;
-        }
-        // If no timestamp placeholder exists, automatically add one before the extension
-        let processedPath = filePath;
-        if (!filePath.includes('{{timestamp}}')) {
-            const lastDot = filePath.lastIndexOf('.');
-            if (lastDot > 0) {
-                const name = filePath.substring(0, lastDot);
-                const ext = filePath.substring(lastDot);
-                processedPath = `${name}-{{timestamp}}${ext}`;
-            }
-            else {
-                processedPath = `${filePath}-{{timestamp}}`;
-            }
-        }
-        // Use FileManager to process timestamp templates
-        return file_manager_1.FileManager.processFilePath(processedPath);
+        logger_1.logger.debug('Test runner initialized');
     }
     async executeLoadPattern() {
         // Setup base directory for CSV files BEFORE creating VUs
@@ -394,12 +192,12 @@ class TestRunner {
         const vuFactory = this.createVUFactory();
         // Support both single load config and array of phases
         const loadPhases = Array.isArray(this.config.load) ? this.config.load : [this.config.load];
-        logger_1.logger.info(`📈 Executing ${loadPhases.length} load phase(s)`);
+        logger_1.logger.info(`Executing ${loadPhases.length} load phase(s)`);
         // Execute each load phase sequentially
         for (let i = 0; i < loadPhases.length; i++) {
             const phase = loadPhases[i];
             const phaseName = phase.name || `Phase ${i + 1}`;
-            logger_1.logger.info(`\n🔄 Starting ${phaseName}: ${phase.pattern} pattern`);
+            logger_1.logger.info(`\nStarting ${phaseName}: ${phase.pattern} pattern`);
             if (phase.virtual_users || phase.vus) {
                 logger_1.logger.info(`   Users: ${phase.virtual_users || phase.vus}, Duration: ${phase.duration}`);
             }
@@ -414,14 +212,14 @@ class TestRunner {
                 this.activeVUs.forEach(vu => vu.stop());
                 this.activeVUs.length = 0;
             }
-            logger_1.logger.success(`✅ Completed ${phaseName}`);
+            logger_1.logger.success(`Completed ${phaseName}`);
             // Small gap between phases
             if (i < loadPhases.length - 1) {
-                logger_1.logger.info('⏸️  Pausing 2s between phases...');
+                logger_1.logger.info('Pausing 2s between phases...');
                 await new Promise(resolve => setTimeout(resolve, 2000));
             }
         }
-        logger_1.logger.success(`\n🎉 All ${loadPhases.length} load phase(s) completed`);
+        logger_1.logger.success(`\nAll ${loadPhases.length} load phase(s) completed`);
     }
     getLoadPatternForPhase(phase) {
         let pattern;
@@ -471,65 +269,42 @@ class TestRunner {
     }
     async waitForVUsToComplete(timeoutMs = 60000) {
         const startTime = Date.now();
-        // Filter to only running VUs
         const getRunningVUs = () => this.activeVUs.filter(vu => vu.isRunning());
         while (getRunningVUs().length > 0 && this.isRunning) {
             const elapsed = Date.now() - startTime;
             const runningCount = getRunningVUs().length;
             if (elapsed > timeoutMs) {
-                logger_1.logger.warn(`⚠️  Timeout waiting for ${runningCount} VUs to complete`);
-                // Force stop remaining VUs
+                logger_1.logger.warn(`Timeout waiting for ${runningCount} VUs to complete`);
                 this.activeVUs.forEach(vu => vu.stop());
                 break;
             }
-            await (0, time_1.sleep)(100); // Check more frequently
-            if (runningCount > 0 && elapsed % 5000 === 0) { // Log every 5 seconds
-                logger_1.logger.debug(`⏳ Waiting for ${runningCount} VUs to complete...`);
+            await (0, time_1.sleep)(100);
+            if (runningCount > 0 && elapsed % 5000 === 0) {
+                logger_1.logger.debug(`Waiting for ${runningCount} VUs to complete...`);
             }
         }
-        // Clear the activeVUs array
         this.activeVUs.length = 0;
-        logger_1.logger.debug('✅ All VUs completed');
-    }
-    async cleanup() {
-        logger_1.logger.debug('🧹 Cleaning up handlers...');
-        // Cleanup protocol handlers
-        for (const [name, handler] of this.handlers) {
-            try {
-                if (handler.cleanup) {
-                    await handler.cleanup();
-                }
-            }
-            catch (error) {
-                logger_1.logger.warn(`⚠️  Error cleaning up ${name} handler:`, error);
-            }
-        }
+        logger_1.logger.debug('All VUs completed');
     }
     async finalize() {
-        logger_1.logger.debug('🏁 Finalizing test...');
+        logger_1.logger.debug('Finalizing test...');
+        // Finalize metrics (stops batch processor timers)
+        await this.metrics.finalize();
         // Cleanup handlers
-        await this.cleanup();
+        await protocol_handler_factory_1.ProtocolHandlerFactory.cleanupHandlers(this.handlers);
         // Generate summary and write to outputs
         const summary = this.metrics.getSummary();
         this.logSummary(summary);
         this.logErrorDetails(summary);
-        // Write summary to outputs
-        for (const output of this.outputs) {
-            try {
-                await output.writeSummary(summary);
-                await output.finalize();
-            }
-            catch (error) {
-                logger_1.logger.warn('⚠️  Output finalization failed:', error);
-            }
-        }
+        // Finalize outputs
+        await output_handler_factory_1.OutputHandlerFactory.finalizeOutputs(this.outputs, summary);
         // Generate HTML report if configured
         if (this.config.report?.generate) {
             await this.generateReport(summary);
         }
     }
     logSummary(summary) {
-        logger_1.logger.info('📊 Test Summary:');
+        logger_1.logger.info('Test Summary:');
         logger_1.logger.info(`   Total Requests: ${summary.total_requests}`);
         logger_1.logger.info(`   Success Rate: ${summary.success_rate.toFixed(2)}%`);
         logger_1.logger.info(`   Avg Response Time: ${summary.avg_response_time.toFixed(2)}ms`);
@@ -538,20 +313,20 @@ class TestRunner {
     }
     logErrorDetails(summary) {
         if (summary.failed_requests > 0) {
-            logger_1.logger.warn(`❌ ${summary.failed_requests} requests failed`);
+            logger_1.logger.warn(`${summary.failed_requests} requests failed`);
             // Log status code distribution
-            logger_1.logger.info('📊 Status Code Distribution:');
+            logger_1.logger.info('Status Code Distribution:');
             Object.entries(summary.status_distribution)
                 .sort(([a], [b]) => parseInt(a) - parseInt(b))
                 .forEach(([status, count]) => {
                 const statusNum = parseInt(status);
                 const isError = statusNum >= 400;
-                const emoji = isError ? '❌' : '✅';
-                logger_1.logger.info(`   ${emoji} ${status}: ${count} requests`);
+                const indicator = isError ? 'ERROR' : 'OK';
+                logger_1.logger.info(`   ${indicator} ${status}: ${count} requests`);
             });
             // Log top errors
             if (summary.error_details && summary.error_details.length > 0) {
-                logger_1.logger.warn('🔍 Top Error Details:');
+                logger_1.logger.warn('Top Error Details:');
                 summary.error_details.slice(0, 5).forEach((error, index) => {
                     logger_1.logger.warn(`   ${index + 1}. ${error.error} (${error.count}x)`);
                     if (error.status) {
@@ -569,8 +344,8 @@ class TestRunner {
     }
     async generateReport(summary) {
         try {
-            const { EnhancedHTMLReportGenerator } = await Promise.resolve().then(() => __importStar(require('../reporting/enhanced-html-generator')));
-            const generator = new EnhancedHTMLReportGenerator();
+            const { HTMLReportGenerator } = await Promise.resolve().then(() => __importStar(require('../reporting/html-generator')));
+            const generator = new HTMLReportGenerator();
             // Process report path with automatic timestamp
             const reportPath = this.processTemplateFilePath(this.config.report.output);
             await generator.generate({
@@ -580,8 +355,26 @@ class TestRunner {
             }, reportPath);
         }
         catch (error) {
-            logger_1.logger.error('❌ Report generation failed:', error);
+            logger_1.logger.error('Report generation failed:', error);
+        }
+    }
+    processTemplateFilePath(filePath) {
+        if (!filePath) {
+            return `results/${this.config.name}-{{timestamp}}.html`;
+        }
+        let processedPath = filePath;
+        if (!filePath.includes('{{timestamp}}')) {
+            const lastDot = filePath.lastIndexOf('.');
+            if (lastDot > 0) {
+                const name = filePath.substring(0, lastDot);
+                const ext = filePath.substring(lastDot);
+                processedPath = `${name}-{{timestamp}}${ext}`;
+            }
+            else {
+                processedPath = `${filePath}-{{timestamp}}`;
+            }
         }
+        return file_manager_1.FileManager.processFilePath(processedPath);
     }
     getMetrics() {
         return this.metrics;

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

@@ -1,11 +1,9 @@
 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';
-}
+import { DataOptions } from './data';
+export { DataOptions as GlobalCSVOptions } from './data';
+export type { DataRow as CSVDataRow } from './data';
 export declare class VirtualUser {
     private id;
     private context;
@@ -13,47 +11,19 @@ export declare class VirtualUser {
     private stepExecutor;
     private isActive;
     private scenarios;
-    private csvProviders;
     private vuHooksManager;
+    private dataManager;
+    private thinkTimeStrategy;
+    private scenarioSelector;
     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);
+    constructor(id: number, metrics: MetricsCollector, handlers: Map<string, ProtocolHandler>, testName?: string, vuHooks?: VUHooks, globalThinkTime?: string | number, globalCSV?: DataOptions);
     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;
-    /**
-     * Select scenarios based on weights using proportional distribution.
-     *
-     * Weights determine the probability of a scenario being selected:
-     * - scenario1 (weight: 50) + scenario2 (weight: 25) + scenario3 (weight: 25) = 100
-     * - 50% of VUs will run scenario1, 25% scenario2, 25% scenario3
-     *
-     * If weights don't sum to 100, they are normalized proportionally.
-     */
-    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;