@testsmith/perfornium 0.1.0

package/dist/metrics/collector.js

@@ -0,0 +1,662 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+const events_1 = require("events");
+const logger_1 = require("../utils/logger");
+class MetricsCollector extends events_1.EventEmitter {
+    constructor(realtimeConfig) {
+        super();
+        this.results = [];
+        this.startTime = 0;
+        this.errorDetails = new Map();
+        this.vuStartEvents = [];
+        this.loadPatternType = 'basic';
+        this.batchBuffer = [];
+        this.batchTimer = null;
+        this.batchCounter = 0;
+        this.csvHeaderWritten = false;
+        // Default output paths
+        this.defaultJsonPath = 'results/live-results.json';
+        this.defaultCsvPath = 'results/live-results.csv';
+        // Enable incremental files by default with sensible defaults
+        this.realtimeConfig = {
+            enabled: true,
+            batch_size: 10, // Default batch size
+            incremental_files: {
+                enabled: true,
+                json_path: this.defaultJsonPath,
+                csv_path: this.defaultCsvPath,
+                update_summary: true
+            },
+            ...realtimeConfig // Override with provided config if any
+        };
+        if (this.realtimeConfig.enabled) {
+            this.initializeRealtime();
+        }
+    }
+    initializeRealtime() {
+        // Use interval-based batching if specified, otherwise use count-based
+        if (this.realtimeConfig.interval_ms) {
+            this.startBatchTimer();
+            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}`);
+        }
+        if (this.realtimeConfig.file_output?.enabled) {
+            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();
+        }
+    }
+    startBatchTimer() {
+        const interval = this.realtimeConfig.interval_ms || 5000;
+        this.batchTimer = setInterval(() => {
+            if (this.batchBuffer.length > 0) {
+                this.flushBatch();
+            }
+        }, interval);
+    }
+    async initializeIncrementalFiles() {
+        const config = this.realtimeConfig.incremental_files;
+        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}`);
+            }
+            // 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}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Failed to initialize incremental files:', error);
+        }
+    }
+    start() {
+        this.startTime = Date.now();
+        this.results = [];
+        this.errorDetails.clear();
+        this.vuStartEvents = [];
+        this.batchBuffer = [];
+        this.batchCounter = 0;
+        this.csvHeaderWritten = false;
+        if (this.realtimeConfig.enabled && this.realtimeConfig.interval_ms) {
+            this.startBatchTimer();
+        }
+    }
+    recordVUStart(vuId) {
+        this.vuStartEvents.push({
+            vu_id: vuId,
+            start_time: Date.now(),
+            load_pattern: this.loadPatternType
+        });
+    }
+    recordResult(result) {
+        this.results.push(result);
+        this.emit('result', result);
+        // Track detailed error information
+        if (!result.success) {
+            this.trackErrorDetail(result);
+        }
+        // Add to batch buffer for real-time processing
+        if (this.realtimeConfig.enabled) {
+            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();
+                }
+            }
+        }
+    }
+    recordError(vuId, scenario, action, error) {
+        const result = {
+            id: `${vuId}-${Date.now()}`,
+            vu_id: vuId,
+            iteration: 0,
+            scenario,
+            action,
+            timestamp: Date.now(),
+            duration: 0,
+            success: false,
+            error: error.message
+        };
+        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}`);
+    }
+    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
+            });
+        }
+    }
+    getResults() {
+        return [...this.results];
+    }
+    // Add method to configure output paths without recreating the collector
+    // Add method to disable incremental files if needed
+    getSummary() {
+        const totalRequests = this.results.length;
+        const successfulRequests = this.results.filter(r => r.success).length;
+        const failedRequests = totalRequests - successfulRequests;
+        const durations = this.results.filter(r => r.success).map(r => r.duration);
+        const totalDuration = (Date.now() - this.startTime) / 1000;
+        // Error distribution by error message
+        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
+        const statusDistribution = {};
+        this.results.forEach(r => {
+            if (r.status) {
+                statusDistribution[r.status] = (statusDistribution[r.status] || 0) + 1;
+            }
+        });
+        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: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+            min_response_time: durations.length > 0 ? Math.min(...durations) : 0,
+            max_response_time: durations.length > 0 ? Math.max(...durations) : 0,
+            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.startTime = 0;
+    }
+}
+exports.MetricsCollector = MetricsCollector;