@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/metrics/collector.js

@@ -3,178 +3,184 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricsCollector = void 0;
 const events_1 = require("events");
 const logger_1 = require("../utils/logger");
+const statistics_engine_1 = require("./core/statistics-engine");
+const error_tracker_1 = require("./core/error-tracker");
+const result_storage_1 = require("./core/result-storage");
+const batch_processor_1 = require("./batch/batch-processor");
+const file_writer_1 = require("./output/file-writer");
+const dispatcher_1 = require("./realtime/dispatcher");
+const summary_generator_1 = require("./reporting/summary-generator");
+const influxdb_writer_1 = require("./output/influxdb-writer");
 class MetricsCollector extends events_1.EventEmitter {
     constructor(realtimeConfig) {
         super();
-        this.results = [];
         this.startTime = 0;
-        this.errorDetails = new Map();
-        this.vuStartEvents = [];
-        this.loadPatternType = 'basic';
-        // Running statistics (accurate even when individual results are dropped)
-        this.runningStats = {
-            totalRequests: 0,
-            successfulRequests: 0,
-            failedRequests: 0,
-            totalDuration: 0, // Sum of all durations for averaging
-            minDuration: Infinity,
-            maxDuration: 0,
-            durations: [], // For percentile calculation (limited size)
-        };
-        this.maxDurationsForPercentiles = 10000; // Keep last N for percentiles
-        this.maxStoredResults = 50000; // Max individual results to keep in memory
-        this.batchBuffer = [];
-        this.batchTimer = null;
-        this.batchCounter = 0;
-        this.csvHeaderWritten = false;
-        // Default output paths
+        this.influxDBWriter = null;
+        // Default output path for live results (used by dashboard)
         this.defaultJsonPath = 'results/live-results.json';
-        this.defaultCsvPath = 'results/live-results.csv';
-        // Enable incremental files by default with sensible defaults
+        // Current test info for InfluxDB
+        this.currentTestId = '';
+        this.currentTestName = '';
+        // Initialize core modules
+        this.statisticsEngine = new statistics_engine_1.StatisticsEngine();
+        this.errorTracker = new error_tracker_1.ErrorTracker();
+        this.resultStorage = new result_storage_1.ResultStorage();
+        this.fileWriter = new file_writer_1.FileWriter();
+        this.realtimeDispatcher = new dispatcher_1.RealtimeDispatcher();
+        this.summaryGenerator = new summary_generator_1.SummaryGenerator();
+        // Enable incremental files by default for dashboard support
         this.realtimeConfig = {
             enabled: true,
-            batch_size: 10, // Default batch size
+            batch_size: 10,
             incremental_files: {
                 enabled: true,
-                json_path: this.defaultJsonPath,
-                csv_path: this.defaultCsvPath,
-                update_summary: true
+                json_path: this.defaultJsonPath
             },
-            ...realtimeConfig // Override with provided config if any
+            ...realtimeConfig
         };
+        // Initialize batch processor with flush handler
+        this.batchProcessor = new batch_processor_1.BatchProcessor({
+            batchSize: this.realtimeConfig.batch_size || 10,
+            intervalMs: this.realtimeConfig.interval_ms,
+            maxBufferSize: 1000
+        });
+        this.batchProcessor.setFlushHandler(async (batch, batchNumber) => {
+            await this.handleBatchFlush(batch, batchNumber);
+        });
+        // Note: initializeRealtime is called separately via initialize() to properly await async operations
+    }
+    /**
+     * Initialize async components (call before starting metrics collection)
+     */
+    async initialize() {
         if (this.realtimeConfig.enabled) {
-            this.initializeRealtime();
+            await this.initializeRealtime();
         }
     }
-    initializeRealtime() {
-        // Use interval-based batching if specified, otherwise use count-based
+    async initializeRealtime() {
         if (this.realtimeConfig.interval_ms) {
-            this.startBatchTimer();
-            logger_1.logger.info(`📊 Real-time metrics enabled with ${this.realtimeConfig.interval_ms}ms intervals`);
+            this.batchProcessor.start();
+            logger_1.logger.info(`Real-time metrics enabled with ${this.realtimeConfig.interval_ms}ms intervals`);
         }
         else {
             const batchSize = this.realtimeConfig.batch_size || 10;
-            logger_1.logger.info(`📊 Real-time metrics enabled with batch size: ${batchSize}`);
+            logger_1.logger.info(`Real-time metrics enabled with batch size: ${batchSize}`);
         }
         if (this.realtimeConfig.file_output?.enabled) {
-            logger_1.logger.info(`📁 Real-time file output enabled: ${this.realtimeConfig.file_output.path}`);
+            logger_1.logger.info(`Real-time file output enabled: ${this.realtimeConfig.file_output.path}`);
         }
         if (this.realtimeConfig.incremental_files?.enabled) {
-            logger_1.logger.info(`📄 Incremental JSON/CSV files enabled (JSON: ${this.realtimeConfig.incremental_files.json_path}, CSV: ${this.realtimeConfig.incremental_files.csv_path})`);
-            this.initializeIncrementalFiles();
+            const config = this.realtimeConfig.incremental_files;
+            logger_1.logger.info(`Live results file enabled: ${config.json_path}`);
+            await this.fileWriter.initialize({
+                enabled: true,
+                jsonPath: config.json_path
+            });
         }
-    }
-    startBatchTimer() {
-        const interval = this.realtimeConfig.interval_ms || 5000;
-        this.batchTimer = setInterval(() => {
-            if (this.batchBuffer.length > 0) {
-                this.flushBatch();
+        if (this.realtimeConfig.endpoints) {
+            this.realtimeDispatcher.setEndpoints(this.realtimeConfig.endpoints);
+        }
+        // Initialize InfluxDB writer if configured
+        if (this.realtimeConfig.influxdb?.enabled) {
+            logger_1.logger.info(`Initializing InfluxDB connection to ${this.realtimeConfig.influxdb.url || 'default URL'}...`);
+            this.influxDBWriter = new influxdb_writer_1.InfluxDBWriter({
+                url: this.realtimeConfig.influxdb.url,
+                token: this.realtimeConfig.influxdb.token,
+                org: this.realtimeConfig.influxdb.org,
+                bucket: this.realtimeConfig.influxdb.bucket,
+                batchSize: this.realtimeConfig.influxdb.batch_size,
+                flushInterval: this.realtimeConfig.influxdb.flush_interval
+            });
+            const connected = await this.influxDBWriter.connect();
+            if (connected) {
+                logger_1.logger.info('InfluxDB test metrics storage enabled and connected');
             }
-        }, interval);
+            else {
+                logger_1.logger.warn('InfluxDB configured but connection failed - metrics will only be stored in files');
+            }
+        }
+        else {
+            logger_1.logger.debug('InfluxDB not configured - test metrics will be stored in files only');
+        }
     }
-    async initializeIncrementalFiles() {
-        const config = this.realtimeConfig.incremental_files;
+    async handleBatchFlush(batch, batchNumber) {
         try {
-            const fs = require('fs').promises;
-            const path = require('path');
-            // Initialize JSON file
-            if (config.json_path) {
-                const dir = path.dirname(config.json_path);
-                await fs.mkdir(dir, { recursive: true });
-                // Start with empty array
-                await fs.writeFile(config.json_path, '[]');
-                logger_1.logger.debug(`📄 Initialized incremental JSON file: ${config.json_path}`);
+            // Write to file if configured
+            if (this.realtimeConfig.file_output?.enabled) {
+                await this.fileWriter.writeBatchToFile(batch, {
+                    enabled: true,
+                    path: this.realtimeConfig.file_output.path,
+                    format: this.realtimeConfig.file_output.format
+                }, batchNumber);
             }
-            // Initialize CSV file with header
-            if (config.csv_path) {
-                const dir = path.dirname(config.csv_path);
-                await fs.mkdir(dir, { recursive: true });
-                const csvHeader = 'timestamp,vu_id,scenario,action,step_name,duration,success,status,error,request_url\n';
-                await fs.writeFile(config.csv_path, csvHeader);
-                this.csvHeaderWritten = true;
-                logger_1.logger.debug(`📄 Initialized incremental CSV file: ${config.csv_path}`);
+            // Send to real-time endpoints
+            await this.realtimeDispatcher.dispatch(batch, batchNumber);
+            // Update live results file (for dashboard)
+            if (this.realtimeConfig.incremental_files?.enabled) {
+                await this.fileWriter.updateIncrementalFiles(batch);
             }
+            // Write to InfluxDB if enabled
+            if (this.influxDBWriter?.isEnabled()) {
+                await this.influxDBWriter.writeBatch(batch);
+            }
+            // Emit batch event for custom listeners
+            this.emit('batch', {
+                batch_number: batchNumber,
+                batch_size: batch.length,
+                results: batch,
+                timestamp: Date.now()
+            });
         }
         catch (error) {
-            logger_1.logger.error('❌ Failed to initialize incremental files:', error);
+            logger_1.logger.error('Failed to flush metrics batch:', error);
         }
     }
-    start() {
+    start(testName) {
         this.startTime = Date.now();
-        this.results = [];
-        this.errorDetails.clear();
-        this.vuStartEvents = [];
-        this.batchBuffer = [];
-        this.batchCounter = 0;
-        this.csvHeaderWritten = false;
-        // Reset running statistics
-        this.runningStats = {
-            totalRequests: 0,
-            successfulRequests: 0,
-            failedRequests: 0,
-            totalDuration: 0,
-            minDuration: Infinity,
-            maxDuration: 0,
-            durations: [],
-        };
+        this.currentTestId = `test-${this.startTime}`;
+        this.currentTestName = testName || 'unnamed-test';
+        // Reset all modules
+        this.statisticsEngine.reset();
+        this.errorTracker.clear();
+        this.resultStorage.clear();
+        this.batchProcessor.reset();
+        this.fileWriter.reset();
+        this.realtimeDispatcher.setStartTime(this.startTime);
+        // Start InfluxDB test if enabled
+        if (this.influxDBWriter?.isEnabled()) {
+            this.influxDBWriter.startTest(this.currentTestId, this.currentTestName);
+        }
         if (this.realtimeConfig.enabled && this.realtimeConfig.interval_ms) {
-            this.startBatchTimer();
+            this.batchProcessor.start();
+        }
+    }
+    /**
+     * Set the test name/ID for InfluxDB tagging
+     */
+    setTestInfo(testName, testId) {
+        this.currentTestName = testName;
+        this.currentTestId = testId || `test-${Date.now()}`;
+        if (this.influxDBWriter?.isEnabled()) {
+            this.influxDBWriter.startTest(this.currentTestId, this.currentTestName);
         }
     }
     recordVUStart(vuId) {
-        this.vuStartEvents.push({
-            vu_id: vuId,
-            start_time: Date.now(),
-            load_pattern: this.loadPatternType
-        });
+        this.resultStorage.recordVUStart(vuId);
     }
     recordResult(result) {
-        // Update running statistics (always accurate regardless of stored results)
-        this.runningStats.totalRequests++;
-        if (result.success) {
-            this.runningStats.successfulRequests++;
-            const duration = result.duration || 0;
-            this.runningStats.totalDuration += duration;
-            this.runningStats.minDuration = Math.min(this.runningStats.minDuration, duration);
-            this.runningStats.maxDuration = Math.max(this.runningStats.maxDuration, duration);
-            // Keep limited durations for percentile calculation (reservoir sampling)
-            if (this.runningStats.durations.length < this.maxDurationsForPercentiles) {
-                this.runningStats.durations.push(duration);
-            }
-            else {
-                // Randomly replace an existing duration (reservoir sampling)
-                const replaceIndex = Math.floor(Math.random() * this.runningStats.totalRequests);
-                if (replaceIndex < this.maxDurationsForPercentiles) {
-                    this.runningStats.durations[replaceIndex] = duration;
-                }
-            }
-        }
-        else {
-            this.runningStats.failedRequests++;
-        }
-        // Store result only if under limit (for detailed analysis)
-        if (this.results.length < this.maxStoredResults) {
-            this.results.push(result);
-        }
+        // Update running statistics
+        const duration = result.duration || 0;
+        this.statisticsEngine.recordResult(duration, result.success);
+        // Store result
+        this.resultStorage.addResult(result);
         this.emit('result', result);
-        // Track detailed error information
+        // Track error details
         if (!result.success) {
-            this.trackErrorDetail(result);
+            this.errorTracker.trackError(result);
         }
-        // Add to batch buffer for real-time processing (with safety limit)
+        // Add to batch for real-time processing
         if (this.realtimeConfig.enabled) {
-            // Safety limit: if buffer exceeds 1000 items, force flush to prevent memory issues
-            if (this.batchBuffer.length >= 1000) {
-                this.flushBatch();
-            }
-            this.batchBuffer.push(result);
-            // Check if we should flush based on batch size (if not using intervals)
-            if (!this.realtimeConfig.interval_ms) {
-                const batchSize = this.realtimeConfig.batch_size || 10;
-                if (this.batchBuffer.length >= batchSize) {
-                    this.flushBatch();
-                }
-            }
+            this.batchProcessor.add(result);
         }
     }
     recordError(vuId, scenario, action, error) {
@@ -191,528 +197,61 @@ class MetricsCollector extends events_1.EventEmitter {
         };
         this.recordResult(result);
     }
-    async flushBatch() {
-        if (this.batchBuffer.length === 0)
-            return;
-        const batch = [...this.batchBuffer];
-        this.batchBuffer = [];
-        this.batchCounter++;
-        logger_1.logger.debug(`📤 Flushing batch #${this.batchCounter} with ${batch.length} results`);
-        try {
-            // Write to file if configured
-            if (this.realtimeConfig.file_output?.enabled) {
-                await this.writeBatchToFile(batch);
-            }
-            // Send to real-time endpoints
-            if (this.realtimeConfig.endpoints) {
-                await this.sendToRealTimeEndpoints(batch);
-            }
-            // Update incremental JSON/CSV files
-            if (this.realtimeConfig.incremental_files?.enabled) {
-                await this.updateIncrementalFiles(batch);
-            }
-            // Emit batch event for custom listeners
-            this.emit('batch', {
-                batch_number: this.batchCounter,
-                batch_size: batch.length,
-                results: batch,
-                timestamp: Date.now()
-            });
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to flush metrics batch:', error);
-        }
-    }
-    async writeBatchToFile(batch) {
-        const config = this.realtimeConfig.file_output;
-        try {
-            const fs = require('fs').promises;
-            const path = require('path');
-            // Ensure directory exists
-            const dir = path.dirname(config.path);
-            await fs.mkdir(dir, { recursive: true });
-            let content;
-            if (config.format === 'csv') {
-                content = this.formatBatchAsCSV(batch);
-            }
-            else {
-                // JSONL format (default)
-                content = batch.map(result => JSON.stringify({
-                    ...result,
-                    timestamp: new Date(result.timestamp).toISOString(),
-                    batch_number: this.batchCounter
-                })).join('\n') + '\n';
-            }
-            await fs.appendFile(config.path, content);
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to write batch to file:', error);
-        }
-    }
-    formatBatchAsCSV(batch) {
-        return batch.map(result => [
-            new Date(result.timestamp).toISOString(),
-            this.batchCounter,
-            result.vu_id,
-            result.scenario,
-            result.action,
-            result.step_name || '',
-            result.duration,
-            result.success,
-            result.status || '',
-            (result.error || '').replace(/"/g, '""') // Escape quotes
-        ].join(',')).join('\n') + '\n';
-    }
-    async updateIncrementalFiles(batch) {
-        const config = this.realtimeConfig.incremental_files;
-        try {
-            // Update incremental JSON file
-            if (config.json_path) {
-                await this.updateIncrementalJSON(batch, config.json_path);
-            }
-            // Update incremental CSV file
-            if (config.csv_path) {
-                await this.updateIncrementalCSV(batch, config.csv_path);
-            }
-            // Update summary files if configured
-            if (config.update_summary) {
-                await this.updateIncrementalSummary();
-            }
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to update incremental files:', error);
-        }
-    }
-    async updateIncrementalJSON(batch, filePath) {
-        const fs = require('fs').promises;
-        try {
-            // Read existing file
-            const existingContent = await fs.readFile(filePath, 'utf8');
-            let existingData = [];
-            if (existingContent.trim()) {
-                existingData = JSON.parse(existingContent);
-            }
-            // Append new batch
-            const updatedData = [...existingData, ...batch];
-            // Write back to file
-            await fs.writeFile(filePath, JSON.stringify(updatedData, null, 2));
-        }
-        catch (error) {
-            // If file doesn't exist or is corrupted, start fresh
-            await fs.writeFile(filePath, JSON.stringify(batch, null, 2));
-        }
-    }
-    async updateIncrementalCSV(batch, filePath) {
-        const fs = require('fs').promises;
-        const csvRows = batch.map(result => [
-            new Date(result.timestamp).toISOString(),
-            result.vu_id,
-            result.scenario,
-            result.action,
-            result.step_name || '',
-            result.duration,
-            result.success,
-            result.status || '',
-            (result.error || '').replace(/"/g, '""'), // Escape quotes
-            result.request_url || ''
-        ].map(field => `"${field}"`).join(',')).join('\n') + '\n';
-        await fs.appendFile(filePath, csvRows);
-    }
-    async updateIncrementalSummary() {
-        const summary = this.getSummary();
-        const fs = require('fs').promises;
-        const path = require('path');
-        const config = this.realtimeConfig.incremental_files;
-        // Generate summary file paths based on the JSON path
-        const basePath = config.json_path ? path.dirname(config.json_path) : 'results';
-        const summaryJsonPath = path.join(basePath, 'summary-incremental.json');
-        const summaryHtmlPath = path.join(basePath, 'summary-incremental.html');
-        try {
-            // Write JSON summary
-            await fs.writeFile(summaryJsonPath, JSON.stringify({
-                last_updated: new Date().toISOString(),
-                test_duration: summary.total_duration,
-                ...summary
-            }, null, 2));
-            // Generate simple HTML summary
-            const htmlSummary = this.generateSimpleHTMLSummary(summary);
-            await fs.writeFile(summaryHtmlPath, htmlSummary);
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to update incremental summary:', error);
-        }
-    }
-    generateSimpleHTMLSummary(summary) {
-        const lastUpdated = new Date().toISOString();
-        return `<!DOCTYPE html>
-<html>
-<head>
-    <title>Load Test Summary (Live)</title>
-    <meta http-equiv="refresh" content="5">
-    <style>
-        body { font-family: Arial, sans-serif; margin: 20px; }
-        .metric { margin: 10px 0; padding: 10px; background: #f5f5f5; border-radius: 4px; }
-        .success { color: #28a745; }
-        .error { color: #dc3545; }
-        .header { background: #007bff; color: white; padding: 15px; border-radius: 4px; }
-    </style>
-</head>
-<body>
-    <div class="header">
-        <h1>🚀 Load Test Progress</h1>
-        <p>Last Updated: ${lastUpdated}</p>
-        <p>Test Duration: ${summary.total_duration.toFixed(1)}s</p>
-    </div>
-    
-    <div class="metric">
-        <h3>📊 Overall Statistics</h3>
-        <p><strong>Total Requests:</strong> ${summary.total_requests}</p>
-        <p><strong class="success">Successful:</strong> ${summary.successful_requests}</p>
-        <p><strong class="error">Failed:</strong> ${summary.failed_requests}</p>
-        <p><strong>Success Rate:</strong> ${summary.success_rate.toFixed(2)}%</p>
-    </div>
-    
-    <div class="metric">
-        <h3>⏱️ Response Times</h3>
-        <p><strong>Average:</strong> ${summary.avg_response_time.toFixed(0)}ms</p>
-        <p><strong>Min:</strong> ${summary.min_response_time}ms</p>
-        <p><strong>Max:</strong> ${summary.max_response_time}ms</p>
-        <p><strong>95th Percentile:</strong> ${summary.percentiles[95] || 0}ms</p>
-    </div>
-    
-    <div class="metric">
-        <h3>🔄 Throughput</h3>
-        <p><strong>Requests/sec:</strong> ${summary.requests_per_second.toFixed(2)}</p>
-        <p><strong>Bytes/sec:</strong> ${(summary.bytes_per_second || 0).toFixed(0)}</p>
-    </div>
-    
-    ${summary.step_statistics.length > 0 ? `
-    <div class="metric">
-        <h3>📝 Step Statistics</h3>
-        ${summary.step_statistics.slice(0, 5).map(step => `
-            <div style="margin: 10px 0; padding: 8px; background: white; border-left: 4px solid ${step.success_rate > 95 ? '#28a745' : '#ffc107'};">
-                <strong>${step.step_name}</strong> (${step.scenario})
-                <br>Success: ${step.success_rate.toFixed(1)}% | Avg: ${step.avg_response_time.toFixed(0)}ms | Count: ${step.total_requests}
-            </div>
-        `).join('')}
-    </div>
-    ` : ''}
-    
-    <div class="metric">
-        <small>Auto-refreshes every 5 seconds</small>
-    </div>
-</body>
-</html>`;
-    }
-    async sendToRealTimeEndpoints(batch) {
-        if (!this.realtimeConfig.endpoints)
-            return;
-        const promises = this.realtimeConfig.endpoints.map(endpoint => this.sendToEndpoint(batch, endpoint).catch(error => logger_1.logger.warn(`⚠️ Failed to send to ${endpoint.type} endpoint:`, error)));
-        await Promise.allSettled(promises);
-    }
-    async sendToEndpoint(batch, endpoint) {
-        switch (endpoint.type) {
-            case 'graphite':
-                await this.sendToGraphite(batch, endpoint);
-                break;
-            case 'webhook':
-                await this.sendToWebhook(batch, endpoint);
-                break;
-            case 'influxdb':
-                await this.sendToInfluxDB(batch, endpoint);
-                break;
-            case 'websocket':
-                await this.sendToWebSocket(batch, endpoint);
-                break;
-            default:
-                logger_1.logger.warn(`⚠️ Unknown endpoint type: ${endpoint.type}`);
-        }
-    }
-    async sendToGraphite(batch, config) {
-        const net = require('net');
-        return new Promise((resolve, reject) => {
-            const client = net.createConnection(config.port, config.host);
-            client.on('connect', () => {
-                const metrics = batch.map(result => {
-                    const timestamp = Math.floor(result.timestamp / 1000);
-                    const metricName = `loadtest.${result.scenario}.${result.step_name || result.action}`;
-                    return [
-                        `${metricName}.duration ${result.duration} ${timestamp}`,
-                        `${metricName}.success ${result.success ? 1 : 0} ${timestamp}`,
-                        `${metricName}.count 1 ${timestamp}`
-                    ].join('\n');
-                }).join('\n') + '\n';
-                client.write(metrics);
-                client.end();
-            });
-            client.on('close', () => resolve());
-            client.on('error', reject);
-            setTimeout(() => {
-                client.destroy();
-                reject(new Error('Graphite connection timeout'));
-            }, 5000);
-        });
-    }
-    async sendToWebhook(batch, config) {
-        const response = await fetch(config.url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...config.headers
-            },
-            body: JSON.stringify({
-                timestamp: new Date().toISOString(),
-                batch_number: this.batchCounter,
-                batch_size: batch.length,
-                test_start_time: new Date(this.startTime).toISOString(),
-                results: batch
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`Webhook failed: ${response.status} ${response.statusText}`);
-        }
-    }
-    async sendToInfluxDB(batch, config) {
-        const lines = batch.map(result => {
-            const tags = [
-                `scenario=${result.scenario}`,
-                `step=${result.step_name || result.action}`,
-                `vu_id=${result.vu_id}`,
-                `success=${result.success}`
-            ].join(',');
-            const fields = [
-                `duration=${result.duration}`,
-                `success=${result.success ? 'true' : 'false'}`,
-                `batch_number=${this.batchCounter}i`
-            ];
-            if (result.status) {
-                fields.push(`status=${result.status}i`);
-            }
-            const timestamp = result.timestamp * 1000000; // Convert to nanoseconds
-            return `loadtest,${tags} ${fields.join(',')} ${timestamp}`;
-        }).join('\n');
-        const response = await fetch(`${config.url}/write?db=${config.database}`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${config.token}`,
-                'Content-Type': 'text/plain'
-            },
-            body: lines
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`InfluxDB write failed: ${response.status} ${errorText}`);
-        }
-    }
-    async sendToWebSocket(batch, config) {
-        return new Promise((resolve, reject) => {
-            const WebSocket = require('ws');
-            const ws = new WebSocket(config.url);
-            ws.on('open', () => {
-                ws.send(JSON.stringify({
-                    type: 'metrics_batch',
-                    timestamp: new Date().toISOString(),
-                    batch_number: this.batchCounter,
-                    test_start_time: new Date(this.startTime).toISOString(),
-                    data: batch
-                }));
-                ws.close();
-                resolve();
-            });
-            ws.on('error', reject);
-            setTimeout(() => {
-                ws.close();
-                reject(new Error('WebSocket connection timeout'));
-            }, 5000);
-        });
-    }
-    // Force flush when test completes or stops
     async finalize() {
-        if (this.batchTimer) {
-            clearInterval(this.batchTimer);
-            this.batchTimer = null;
-        }
-        // Flush any remaining results
-        if (this.batchBuffer.length > 0) {
-            await this.flushBatch();
-        }
-        logger_1.logger.info(`📊 Metrics collection finalized. Total batches: ${this.batchCounter}, Total results: ${this.results.length}`);
+        await this.batchProcessor.finalize();
+        // Write summary to InfluxDB and finalize
+        if (this.influxDBWriter?.isEnabled()) {
+            const summary = this.getSummary();
+            await this.influxDBWriter.writeSummary(summary);
+            await this.influxDBWriter.finalize();
+        }
+        logger_1.logger.info(`Metrics collection finalized. Total batches: ${this.batchProcessor.getBatchCounter()}, Total results: ${this.resultStorage.getResultCount()}`);
     }
-    trackErrorDetail(result) {
-        const errorKey = `${result.scenario}:${result.action}:${result.status || 'NO_STATUS'}:${result.error}`;
-        const existing = this.errorDetails.get(errorKey);
-        if (existing) {
-            existing.count++;
-        }
-        else {
-            this.errorDetails.set(errorKey, {
-                timestamp: result.timestamp,
-                vu_id: result.vu_id,
-                scenario: result.scenario,
-                action: result.action,
-                status: result.status,
-                error: result.error || 'Unknown error',
-                request_url: result.request_url,
-                response_body: result.response_body,
-                count: 1
-            });
+    /**
+     * Record a network call to InfluxDB (if enabled)
+     */
+    recordNetworkCall(call) {
+        if (this.influxDBWriter?.isEnabled()) {
+            this.influxDBWriter.writeNetworkCall(call);
         }
     }
+    /**
+     * Get the InfluxDB writer instance (for direct access if needed)
+     */
+    getInfluxDBWriter() {
+        return this.influxDBWriter;
+    }
     getResults() {
-        return [...this.results];
+        return this.resultStorage.getResults();
     }
     getSummary() {
-        // Use running statistics for accurate totals (even when individual results are limited)
-        const totalRequests = this.runningStats.totalRequests;
-        const successfulRequests = this.runningStats.successfulRequests;
-        const failedRequests = this.runningStats.failedRequests;
-        // Use sampled durations for percentiles (reservoir sampling ensures representative sample)
-        const durations = this.runningStats.durations;
-        const totalDuration = (Date.now() - this.startTime) / 1000;
-        // Calculate average from running totals (accurate even with limited stored results)
-        const avgResponseTime = successfulRequests > 0
-            ? this.runningStats.totalDuration / successfulRequests
-            : 0;
-        // Error distribution from stored results (may be limited but representative)
-        const errorDistribution = {};
-        this.results.filter(r => !r.success).forEach(r => {
-            const error = r.error || 'Unknown error';
-            errorDistribution[error] = (errorDistribution[error] || 0) + 1;
-        });
-        // Status code distribution from stored results
-        const statusDistribution = {};
-        this.results.forEach(r => {
-            if (r.status) {
-                statusDistribution[r.status] = (statusDistribution[r.status] || 0) + 1;
-            }
+        return this.summaryGenerator.generate({
+            statisticsEngine: this.statisticsEngine,
+            errorTracker: this.errorTracker,
+            results: this.resultStorage.getResults(),
+            vuStartEvents: this.resultStorage.getVUStartEvents(),
+            startTime: this.startTime
         });
-        const responseSizes = this.results
-            .filter(r => r.response_size)
-            .map(r => r.response_size);
-        return {
-            total_requests: totalRequests,
-            successful_requests: successfulRequests,
-            failed_requests: failedRequests,
-            success_rate: totalRequests > 0 ? (successfulRequests / totalRequests) * 100 : 0,
-            avg_response_time: avgResponseTime,
-            min_response_time: this.runningStats.minDuration === Infinity ? 0 : this.runningStats.minDuration,
-            max_response_time: this.runningStats.maxDuration,
-            percentiles: this.calculatePercentiles(durations),
-            requests_per_second: totalDuration > 0 ? (totalRequests / totalDuration) : 0,
-            bytes_per_second: responseSizes.length > 0 && totalDuration > 0
-                ? (responseSizes.reduce((a, b) => a + b, 0) / totalDuration) : 0,
-            total_duration: totalDuration,
-            error_distribution: errorDistribution,
-            status_distribution: statusDistribution,
-            error_details: Array.from(this.errorDetails.values()).sort((a, b) => b.count - a.count),
-            // New enhanced statistics
-            step_statistics: this.calculateStepStatistics(),
-            vu_ramp_up: this.vuStartEvents,
-            timeline_data: this.calculateTimelineData()
-        };
-    }
-    calculateStepStatistics() {
-        const stepGroups = new Map();
-        // Group results by step name and scenario
-        this.results.forEach(result => {
-            const key = `${result.scenario}:${result.step_name || result.action}`;
-            if (!stepGroups.has(key)) {
-                stepGroups.set(key, []);
-            }
-            stepGroups.get(key).push(result);
-        });
-        const stepStats = [];
-        for (const [key, results] of stepGroups) {
-            const [scenario, stepName] = key.split(':');
-            const successfulResults = results.filter(r => r.success);
-            // Include ALL results (both successful and failed) for response time calculations
-            // Failed requests also have response times that should be included in statistics
-            const responseTimes = results
-                .map(r => r.response_time || r.duration || 0)
-                .filter(rt => rt > 0);
-            // Error distribution for this step
-            const errorDistribution = {};
-            results.filter(r => !r.success).forEach(r => {
-                const error = r.error || 'Unknown error';
-                errorDistribution[error] = (errorDistribution[error] || 0) + 1;
-            });
-            // Status distribution for this step
-            const statusDistribution = {};
-            results.forEach(r => {
-                if (r.status) {
-                    statusDistribution[r.status] = (statusDistribution[r.status] || 0) + 1;
-                }
-            });
-            stepStats.push({
-                step_name: stepName,
-                scenario: scenario,
-                total_requests: results.length,
-                successful_requests: successfulResults.length,
-                failed_requests: results.length - successfulResults.length,
-                success_rate: results.length > 0 ? (successfulResults.length / results.length) * 100 : 0,
-                avg_response_time: responseTimes.length > 0 ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length : 0,
-                min_response_time: responseTimes.length > 0 ? Math.min(...responseTimes) : 0,
-                max_response_time: responseTimes.length > 0 ? Math.max(...responseTimes) : 0,
-                percentiles: this.calculatePercentiles(responseTimes),
-                response_times: responseTimes,
-                error_distribution: errorDistribution,
-                status_distribution: statusDistribution
-            });
-        }
-        return stepStats.sort((a, b) => b.total_requests - a.total_requests);
-    }
-    calculateTimelineData() {
-        if (this.results.length === 0)
-            return [];
-        const intervalMs = 5000; // 5 second intervals
-        const startTime = this.startTime;
-        const endTime = Date.now();
-        const timeline = [];
-        for (let time = startTime; time <= endTime; time += intervalMs) {
-            const intervalResults = this.results.filter(r => r.timestamp >= time && r.timestamp < time + intervalMs);
-            const successfulResults = intervalResults.filter(r => r.success);
-            // Calculate active VUs at this time
-            const activeVUs = this.vuStartEvents.filter(vu => vu.start_time <= time).length;
-            timeline.push({
-                timestamp: time,
-                time_label: new Date(time).toISOString(),
-                active_vus: activeVUs,
-                requests_count: intervalResults.length,
-                avg_response_time: successfulResults.length > 0
-                    ? successfulResults.reduce((sum, r) => sum + r.duration, 0) / successfulResults.length
-                    : 0,
-                success_rate: intervalResults.length > 0
-                    ? (successfulResults.length / intervalResults.length) * 100
-                    : 0,
-                throughput: intervalResults.length / (intervalMs / 1000)
-            });
-        }
-        return timeline;
-    }
-    calculatePercentiles(values) {
-        if (values.length === 0)
-            return {};
-        const sorted = [...values].sort((a, b) => a - b);
-        const percentiles = [50, 90, 95, 99, 99.9, 99.99];
-        const result = {};
-        percentiles.forEach(p => {
-            const index = Math.ceil((p / 100) * sorted.length) - 1;
-            result[p] = sorted[Math.max(0, index)];
-        });
-        return result;
     }
     clear() {
-        if (this.batchTimer) {
-            clearInterval(this.batchTimer);
-            this.batchTimer = null;
-        }
-        this.results = [];
-        this.errorDetails.clear();
-        this.vuStartEvents = [];
-        this.batchBuffer = [];
-        this.batchCounter = 0;
-        this.csvHeaderWritten = false;
+        this.batchProcessor.stop();
+        this.statisticsEngine.reset();
+        this.errorTracker.clear();
+        this.resultStorage.clear();
+        this.batchProcessor.reset();
+        this.fileWriter.reset();
         this.startTime = 0;
+        this.currentTestId = '';
+        this.currentTestName = '';
+    }
+    /**
+     * Close all connections (call when done with the collector)
+     */
+    async close() {
+        this.clear();
+        if (this.influxDBWriter) {
+            await this.influxDBWriter.close();
+        }
     }
 }
 exports.MetricsCollector = MetricsCollector;