@testsmith/perfornium 0.1.0

package/dist/outputs/json.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONOutput = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class JSONOutput {
+    constructor(filePath) {
+        this.results = [];
+        this.firstWrite = true;
+        this.filePath = filePath;
+    }
+    async initialize() {
+        // Ensure directory exists
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Create file and write opening structure
+        this.fileStream = fs.createWriteStream(this.filePath, { flags: 'w' });
+        this.fileStream.write('{\n');
+        this.fileStream.write('  "metadata": {\n');
+        this.fileStream.write('    "version": "1.0.0",\n');
+        this.fileStream.write(`    "generated_at": "${new Date().toISOString()}",\n`);
+        this.fileStream.write('    "test_status": "running"\n');
+        this.fileStream.write('  },\n');
+        this.fileStream.write('  "results": [\n');
+        this.firstWrite = true;
+    }
+    async writeResult(result) {
+        // Write incrementally to file during test
+        this.results.push(result); // Keep for summary calculation
+        if (!this.fileStream) {
+            throw new Error('JSON output not initialized');
+        }
+        // Add comma before all results except the first
+        if (!this.firstWrite) {
+            this.fileStream.write(',\n');
+        }
+        this.firstWrite = false;
+        // Write result as indented JSON
+        const resultJson = JSON.stringify(result, null, 2);
+        const indentedResult = resultJson.split('\n').map((line, idx) => {
+            if (idx === 0)
+                return `    ${line}`;
+            return `    ${line}`;
+        }).join('\n');
+        this.fileStream.write(indentedResult);
+    }
+    async writeSummary(summary) {
+        this.summary = summary;
+    }
+    async finalize() {
+        if (!this.fileStream)
+            return;
+        // Close results array
+        this.fileStream.write('\n  ]');
+        // Write summary if available
+        if (this.summary) {
+            this.fileStream.write(',\n  "summary": ');
+            const summaryJson = JSON.stringify(this.summary, null, 2);
+            const indentedSummary = summaryJson.split('\n').map((line, idx) => {
+                if (idx === 0)
+                    return line;
+                return `  ${line}`;
+            }).join('\n');
+            this.fileStream.write(indentedSummary);
+        }
+        // Close root object
+        this.fileStream.write('\n}\n');
+        // Close file stream
+        this.fileStream.end();
+    }
+}
+exports.JSONOutput = JSONOutput;

package/dist/outputs/streaming-csv.d.ts

@@ -0,0 +1,37 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export interface StreamingCSVConfig {
+    batchSize?: number;
+    flushInterval?: number;
+    immediateWrite?: boolean;
+    rotateSize?: number;
+    maxFiles?: number;
+}
+export declare class StreamingCSVOutput implements OutputHandler {
+    private filePath;
+    private csvWriter;
+    private pendingResults;
+    private config;
+    private flushTimer?;
+    private fileStream?;
+    private headerWritten;
+    private totalResults;
+    private currentFileSize;
+    private rotationIndex;
+    private readonly DEFAULT_CONFIG;
+    constructor(filePath: string, config?: StreamingCSVConfig);
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    private flushPending;
+    private rotateFile;
+    private cleanupOldFiles;
+    private extractRotationIndex;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+    getStats(): {
+        totalResults: number;
+        pendingResults: number;
+        currentFileSize: number;
+        rotationIndex: number;
+    };
+}

package/dist/outputs/streaming-csv.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingCSVOutput = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const csv_writer_1 = require("csv-writer");
+const file_manager_1 = require("../utils/file-manager");
+const logger_1 = require("../utils/logger");
+class StreamingCSVOutput {
+    constructor(filePath, config) {
+        this.pendingResults = [];
+        this.headerWritten = false;
+        this.totalResults = 0;
+        this.currentFileSize = 0;
+        this.rotationIndex = 0;
+        this.DEFAULT_CONFIG = {
+            batchSize: 100,
+            flushInterval: 5000,
+            immediateWrite: false,
+            rotateSize: 50 * 1024 * 1024, // 50MB
+            maxFiles: 5
+        };
+        this.filePath = filePath;
+        this.config = { ...this.DEFAULT_CONFIG, ...config };
+    }
+    async initialize() {
+        // Process template in file path
+        this.filePath = file_manager_1.FileManager.processFilePath(this.filePath);
+        // Ensure directory exists
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Initialize CSV writer
+        this.csvWriter = (0, csv_writer_1.createObjectCsvWriter)({
+            path: this.filePath,
+            header: [
+                { id: 'timestamp', title: 'timestamp' },
+                { id: 'vu_id', title: 'vu_id' },
+                { id: 'iteration', title: 'iteration' },
+                { id: 'scenario', title: 'scenario' },
+                { id: 'name', title: 'request_name' },
+                { id: 'response_time', title: 'response_time_ms' },
+                { id: 'success', title: 'success' },
+                { id: 'status', title: 'http_status' },
+                { id: 'error', title: 'error' },
+                { id: 'response_size', title: 'response_size_bytes' },
+                { id: 'request_url', title: 'url' }
+            ]
+        });
+        // Start flush timer if configured
+        if (this.config.flushInterval > 0 && !this.config.immediateWrite) {
+            this.flushTimer = setInterval(() => {
+                this.flushPending();
+            }, this.config.flushInterval);
+        }
+        logger_1.logger.info(`📊 Streaming CSV output initialized: ${this.filePath}`);
+        logger_1.logger.debug(`📊 Config: batch=${this.config.batchSize}, flush=${this.config.flushInterval}ms`);
+    }
+    async writeResult(result) {
+        // Add processed timestamp and normalize data
+        const processedResult = {
+            ...result,
+            timestamp: result.timestamp || Date.now(),
+            response_time: result.response_time || result.duration || 0,
+            name: result.name || result.action || 'request',
+            iteration: result.iteration || 0
+        };
+        this.pendingResults.push(processedResult);
+        this.totalResults++;
+        if (this.config.immediateWrite) {
+            await this.flushPending();
+        }
+        else if (this.pendingResults.length >= this.config.batchSize) {
+            await this.flushPending();
+        }
+    }
+    async flushPending() {
+        if (this.pendingResults.length === 0)
+            return;
+        try {
+            // Check if we need to rotate the file
+            if (this.config.rotateSize > 0 && this.currentFileSize > this.config.rotateSize) {
+                await this.rotateFile();
+            }
+            // Write the batch
+            const recordsToWrite = [...this.pendingResults];
+            this.pendingResults = [];
+            await this.csvWriter.writeRecords(recordsToWrite);
+            // Update file size estimate
+            this.currentFileSize += recordsToWrite.length * 200; // Rough estimate
+            logger_1.logger.debug(`📊 Wrote ${recordsToWrite.length} results to CSV (total: ${this.totalResults})`);
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Failed to write CSV batch:', error);
+            // Re-add results to pending for retry
+            this.pendingResults.unshift(...this.pendingResults);
+        }
+    }
+    async rotateFile() {
+        try {
+            // Close current file
+            if (this.fileStream) {
+                this.fileStream.end();
+                this.fileStream = undefined;
+            }
+            // Create rotated filename
+            const ext = path.extname(this.filePath);
+            const base = this.filePath.slice(0, -ext.length);
+            const rotatedPath = `${base}.${this.rotationIndex}${ext}`;
+            // Rename current file
+            if (fs.existsSync(this.filePath)) {
+                fs.renameSync(this.filePath, rotatedPath);
+            }
+            // Clean up old files if needed
+            if (this.config.maxFiles > 0) {
+                this.cleanupOldFiles(base, ext);
+            }
+            // Reset for new file
+            this.rotationIndex++;
+            this.currentFileSize = 0;
+            // Recreate CSV writer for new file
+            await this.initialize();
+            logger_1.logger.info(`🔄 Rotated CSV file: ${this.filePath}`);
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Failed to rotate CSV file:', error);
+        }
+    }
+    cleanupOldFiles(basePath, extension) {
+        try {
+            const dir = path.dirname(basePath);
+            const basename = path.basename(basePath);
+            const files = fs.readdirSync(dir)
+                .filter(file => file.startsWith(basename) && file.endsWith(extension))
+                .map(file => ({
+                name: file,
+                path: path.join(dir, file),
+                index: this.extractRotationIndex(file)
+            }))
+                .filter(file => file.index >= 0)
+                .sort((a, b) => b.index - a.index);
+            // Remove excess files
+            const filesToRemove = files.slice(this.config.maxFiles);
+            for (const file of filesToRemove) {
+                fs.unlinkSync(file.path);
+                logger_1.logger.debug(`🗑️ Removed old CSV file: ${file.name}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️ Failed to cleanup old CSV files:', error);
+        }
+    }
+    extractRotationIndex(filename) {
+        const match = filename.match(/\.(\d+)\.csv$/);
+        return match ? parseInt(match[1], 10) : -1;
+    }
+    async writeSummary(summary) {
+        // Write summary to separate file
+        const summaryPath = this.filePath.replace('.csv', '_summary.csv');
+        const summaryWriter = (0, csv_writer_1.createObjectCsvWriter)({
+            path: summaryPath,
+            header: [
+                { id: 'metric', title: 'metric' },
+                { id: 'value', title: 'value' },
+                { id: 'unit', title: 'unit' },
+                { id: 'timestamp', title: 'timestamp' }
+            ]
+        });
+        const timestamp = Date.now();
+        const summaryData = [
+            { metric: 'total_requests', value: summary.total_requests, unit: 'count', timestamp },
+            { metric: 'successful_requests', value: summary.successful_requests, unit: 'count', timestamp },
+            { metric: 'failed_requests', value: summary.failed_requests, unit: 'count', timestamp },
+            { metric: 'success_rate', value: summary.success_rate?.toFixed(2) || '0', unit: 'percent', timestamp },
+            { metric: 'avg_response_time', value: summary.avg_response_time?.toFixed(2) || '0', unit: 'ms', timestamp },
+            { metric: 'min_response_time', value: summary.min_response_time || 0, unit: 'ms', timestamp },
+            { metric: 'max_response_time', value: summary.max_response_time || 0, unit: 'ms', timestamp },
+            { metric: 'requests_per_second', value: summary.requests_per_second?.toFixed(2) || '0', unit: 'req/s', timestamp },
+            { metric: 'total_duration', value: summary.total_duration || 0, unit: 'ms', timestamp }
+        ];
+        // Add percentiles
+        if (summary.percentiles) {
+            Object.entries(summary.percentiles).forEach(([p, value]) => {
+                summaryData.push({
+                    metric: `p${p}_response_time`,
+                    value: typeof value === 'number' ? value.toFixed(2) : '0',
+                    unit: 'ms',
+                    timestamp
+                });
+            });
+        }
+        await summaryWriter.writeRecords(summaryData);
+        logger_1.logger.info(`📊 Written CSV summary: ${summaryPath}`);
+    }
+    async finalize() {
+        // Flush any remaining results
+        await this.flushPending();
+        // Clear flush timer
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        // Close file stream
+        if (this.fileStream) {
+            this.fileStream.end();
+            this.fileStream = undefined;
+        }
+        logger_1.logger.info(`📊 Streaming CSV finalized. Total results: ${this.totalResults}`);
+    }
+    // Real-time statistics
+    getStats() {
+        return {
+            totalResults: this.totalResults,
+            pendingResults: this.pendingResults.length,
+            currentFileSize: this.currentFileSize,
+            rotationIndex: this.rotationIndex
+        };
+    }
+}
+exports.StreamingCSVOutput = StreamingCSVOutput;

package/dist/outputs/streaming-json.d.ts

@@ -0,0 +1,43 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export interface StreamingJSONConfig {
+    format?: 'ndjson' | 'json-array' | 'json-stream';
+    batchSize?: number;
+    flushInterval?: number;
+    prettify?: boolean;
+    includeMetadata?: boolean;
+    rotateSize?: number;
+    maxFiles?: number;
+}
+export declare class StreamingJSONOutput implements OutputHandler {
+    private filePath;
+    private config;
+    private pendingResults;
+    private fileStream?;
+    private flushTimer?;
+    private totalResults;
+    private currentFileSize;
+    private rotationIndex;
+    private isFirstWrite;
+    private testStartTime;
+    private readonly DEFAULT_CONFIG;
+    constructor(filePath: string, config?: StreamingJSONConfig);
+    initialize(): Promise<void>;
+    private writeHeader;
+    writeResult(result: TestResult): Promise<void>;
+    private flushPending;
+    private writeRecords;
+    private rotateFile;
+    private closeCurrentFile;
+    private cleanupOldFiles;
+    private extractRotationIndex;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+    getStats(): {
+        totalResults: number;
+        pendingResults: number;
+        currentFileSize: number;
+        rotationIndex: number;
+        format: string;
+    };
+}