@testsmith/perfornium 0.1.0

package/dist/outputs/streaming-json.js

@@ -0,0 +1,353 @@
+"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.StreamingJSONOutput = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_manager_1 = require("../utils/file-manager");
+const logger_1 = require("../utils/logger");
+class StreamingJSONOutput {
+    constructor(filePath, config) {
+        this.pendingResults = [];
+        this.totalResults = 0;
+        this.currentFileSize = 0;
+        this.rotationIndex = 0;
+        this.isFirstWrite = true;
+        this.testStartTime = Date.now();
+        this.DEFAULT_CONFIG = {
+            format: 'ndjson',
+            batchSize: 50,
+            flushInterval: 3000,
+            prettify: false,
+            includeMetadata: true,
+            rotateSize: 100 * 1024 * 1024, // 100MB
+            maxFiles: 3
+        };
+        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 });
+        }
+        // Create write stream
+        this.fileStream = fs.createWriteStream(this.filePath, { flags: 'w' });
+        // Write file header based on format
+        await this.writeHeader();
+        // Start flush timer
+        if (this.config.flushInterval > 0) {
+            this.flushTimer = setInterval(() => {
+                this.flushPending();
+            }, this.config.flushInterval);
+        }
+        logger_1.logger.info(`📊 Streaming JSON output initialized: ${this.filePath}`);
+        logger_1.logger.debug(`📊 Format: ${this.config.format}, batch: ${this.config.batchSize}`);
+    }
+    async writeHeader() {
+        if (!this.fileStream)
+            return;
+        switch (this.config.format) {
+            case 'json-array':
+                if (this.config.includeMetadata) {
+                    const metadata = {
+                        _metadata: {
+                            format: 'perfornium-results',
+                            version: '1.0',
+                            test_start: new Date(this.testStartTime).toISOString(),
+                            generator: 'perfornium-streaming-json'
+                        },
+                        results: []
+                    };
+                    this.fileStream.write('{\n');
+                    this.fileStream.write(`  "_metadata": ${JSON.stringify(metadata._metadata, null, 2).replace(/\n/g, '\n  ')},\n`);
+                    this.fileStream.write('  "results": [\n');
+                }
+                else {
+                    this.fileStream.write('[\n');
+                }
+                break;
+            case 'json-stream':
+                if (this.config.includeMetadata) {
+                    const metadata = {
+                        type: 'metadata',
+                        format: 'perfornium-results',
+                        version: '1.0',
+                        test_start: new Date(this.testStartTime).toISOString(),
+                        generator: 'perfornium-streaming-json'
+                    };
+                    this.fileStream.write(JSON.stringify(metadata) + '\n');
+                }
+                break;
+            case 'ndjson':
+            default:
+                // NDJSON doesn't need a header, but we can add metadata as first line
+                if (this.config.includeMetadata) {
+                    const metadata = {
+                        _type: 'metadata',
+                        format: 'perfornium-results',
+                        version: '1.0',
+                        test_start: new Date(this.testStartTime).toISOString(),
+                        generator: 'perfornium-streaming-json'
+                    };
+                    this.fileStream.write(JSON.stringify(metadata) + '\n');
+                }
+                break;
+        }
+        this.currentFileSize = this.fileStream.bytesWritten || 0;
+    }
+    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.pendingResults.length >= this.config.batchSize) {
+            await this.flushPending();
+        }
+    }
+    async flushPending() {
+        if (this.pendingResults.length === 0 || !this.fileStream)
+            return;
+        try {
+            // Check if we need to rotate the file
+            if (this.config.rotateSize > 0 && this.currentFileSize > this.config.rotateSize) {
+                await this.rotateFile();
+            }
+            const recordsToWrite = [...this.pendingResults];
+            this.pendingResults = [];
+            // Write records based on format
+            await this.writeRecords(recordsToWrite);
+            this.currentFileSize = this.fileStream.bytesWritten || 0;
+            logger_1.logger.debug(`📊 Wrote ${recordsToWrite.length} JSON results (total: ${this.totalResults})`);
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Failed to write JSON batch:', error);
+            // Re-add results to pending for retry
+            this.pendingResults.unshift(...this.pendingResults);
+        }
+    }
+    async writeRecords(records) {
+        if (!this.fileStream)
+            return;
+        switch (this.config.format) {
+            case 'json-array':
+                for (let i = 0; i < records.length; i++) {
+                    const record = records[i];
+                    const isLast = i === records.length - 1;
+                    const json = this.config.prettify
+                        ? JSON.stringify(record, null, 2).replace(/\n/g, '\n    ')
+                        : JSON.stringify(record);
+                    if (!this.isFirstWrite) {
+                        this.fileStream.write(',\n');
+                    }
+                    this.fileStream.write(`    ${json}`);
+                    this.isFirstWrite = false;
+                }
+                break;
+            case 'json-stream':
+                for (const record of records) {
+                    const streamRecord = {
+                        type: 'result',
+                        timestamp: Date.now(),
+                        data: record
+                    };
+                    const json = this.config.prettify
+                        ? JSON.stringify(streamRecord, null, 2)
+                        : JSON.stringify(streamRecord);
+                    this.fileStream.write(json + '\n');
+                }
+                break;
+            case 'ndjson':
+            default:
+                for (const record of records) {
+                    const json = this.config.prettify
+                        ? JSON.stringify(record, null, 2)
+                        : JSON.stringify(record);
+                    this.fileStream.write(json + '\n');
+                }
+                break;
+        }
+    }
+    async rotateFile() {
+        try {
+            // Close current file properly
+            await this.closeCurrentFile();
+            // 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
+            this.cleanupOldFiles(base, ext);
+            // Reset state
+            this.rotationIndex++;
+            this.currentFileSize = 0;
+            this.isFirstWrite = true;
+            // Reinitialize for new file
+            await this.initialize();
+            logger_1.logger.info(`🔄 Rotated JSON file: ${this.filePath}`);
+        }
+        catch (error) {
+            logger_1.logger.error('❌ Failed to rotate JSON file:', error);
+        }
+    }
+    async closeCurrentFile() {
+        if (!this.fileStream)
+            return;
+        // Write file footer based on format
+        switch (this.config.format) {
+            case 'json-array':
+                this.fileStream.write('\n  ]');
+                if (this.config.includeMetadata) {
+                    const endMetadata = {
+                        test_end: new Date().toISOString(),
+                        total_results: this.totalResults,
+                        duration_ms: Date.now() - this.testStartTime
+                    };
+                    this.fileStream.write(',\n  "_summary": ' + JSON.stringify(endMetadata, null, 2).replace(/\n/g, '\n  '));
+                }
+                this.fileStream.write('\n}\n');
+                break;
+            case 'json-stream':
+                if (this.config.includeMetadata) {
+                    const endMetadata = {
+                        type: 'summary',
+                        test_end: new Date().toISOString(),
+                        total_results: this.totalResults,
+                        duration_ms: Date.now() - this.testStartTime
+                    };
+                    this.fileStream.write(JSON.stringify(endMetadata) + '\n');
+                }
+                break;
+            case 'ndjson':
+            default:
+                if (this.config.includeMetadata) {
+                    const endMetadata = {
+                        _type: 'summary',
+                        test_end: new Date().toISOString(),
+                        total_results: this.totalResults,
+                        duration_ms: Date.now() - this.testStartTime
+                    };
+                    this.fileStream.write(JSON.stringify(endMetadata) + '\n');
+                }
+                break;
+        }
+        return new Promise((resolve) => {
+            this.fileStream.end(() => {
+                this.fileStream = undefined;
+                resolve();
+            });
+        });
+    }
+    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 JSON file: ${file.name}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️ Failed to cleanup old JSON files:', error);
+        }
+    }
+    extractRotationIndex(filename) {
+        const match = filename.match(/\.(\d+)\.json$/);
+        return match ? parseInt(match[1], 10) : -1;
+    }
+    async writeSummary(summary) {
+        // Write summary to separate file
+        const summaryPath = this.filePath.replace('.json', '_summary.json');
+        const summaryData = {
+            test_summary: {
+                timestamp: Date.now(),
+                test_end: new Date().toISOString(),
+                total_duration_ms: Date.now() - this.testStartTime,
+                ...summary
+            }
+        };
+        const json = this.config.prettify
+            ? JSON.stringify(summaryData, null, 2)
+            : JSON.stringify(summaryData);
+        fs.writeFileSync(summaryPath, json);
+        logger_1.logger.info(`📊 Written JSON 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 properly
+        await this.closeCurrentFile();
+        logger_1.logger.info(`📊 Streaming JSON finalized. Total results: ${this.totalResults}`);
+    }
+    getStats() {
+        return {
+            totalResults: this.totalResults,
+            pendingResults: this.pendingResults.length,
+            currentFileSize: this.currentFileSize,
+            rotationIndex: this.rotationIndex,
+            format: this.config.format || 'ndjson'
+        };
+    }
+}
+exports.StreamingJSONOutput = StreamingJSONOutput;

package/dist/outputs/webhook.d.ts

@@ -0,0 +1,16 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export declare class WebhookOutput implements OutputHandler {
+    private url;
+    private headers;
+    private format;
+    private template?;
+    private templateProcessor;
+    private results;
+    constructor(url: string, headers?: Record<string, string>, format?: string, template?: string);
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    private sendNotification;
+    finalize(): Promise<void>;
+}

package/dist/outputs/webhook.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookOutput = void 0;
+const axios_1 = __importDefault(require("axios"));
+const template_1 = require("../utils/template");
+const logger_1 = require("../utils/logger");
+class WebhookOutput {
+    constructor(url, headers = {}, format = 'json', template) {
+        this.templateProcessor = new template_1.TemplateProcessor();
+        this.results = [];
+        this.url = url;
+        this.headers = {
+            'Content-Type': 'application/json',
+            'User-Agent': 'Perfornium/1.0.0',
+            ...headers
+        };
+        this.format = format;
+        this.template = template;
+    }
+    async initialize() {
+        // Test webhook connectivity
+        try {
+            await axios_1.default.head(this.url, {
+                headers: this.headers,
+                timeout: 5000
+            });
+            logger_1.logger.debug('🔗 Webhook endpoint is reachable');
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Webhook endpoint may not be reachable:', error);
+        }
+    }
+    async writeResult(result) {
+        this.results.push(result);
+        // Optionally send real-time results for critical failures
+        if (!result.success && result.error && result.error.includes('timeout')) {
+            await this.sendNotification({
+                type: 'alert',
+                message: `Critical error in VU ${result.vu_id}: ${result.error}`,
+                timestamp: new Date().toISOString()
+            });
+        }
+    }
+    async writeSummary(summary) {
+        try {
+            let payload;
+            if (this.template) {
+                // Use template to format payload
+                const context = {
+                    summary,
+                    test_name: 'Performance Test',
+                    success_rate: summary.success_rate.toFixed(2),
+                    avg_response_time: summary.avg_response_time.toFixed(2),
+                    total_requests: summary.total_requests,
+                    total_duration: summary.total_duration
+                };
+                const processedTemplate = this.templateProcessor.process(this.template, context);
+                payload = JSON.parse(processedTemplate);
+            }
+            else {
+                // Default payload format
+                payload = {
+                    type: 'test_completed',
+                    timestamp: new Date().toISOString(),
+                    summary: {
+                        total_requests: summary.total_requests,
+                        success_rate: `${summary.success_rate.toFixed(2)}%`,
+                        avg_response_time: `${summary.avg_response_time.toFixed(2)}ms`,
+                        requests_per_second: summary.requests_per_second.toFixed(2),
+                        duration: `${(summary.total_duration / 1000).toFixed(1)}s`,
+                        status: summary.success_rate >= 95 ? 'success' : summary.success_rate >= 90 ? 'warning' : 'error'
+                    },
+                    errors: Object.keys(summary.error_distribution).length > 0 ? summary.error_distribution : null
+                };
+            }
+            await this.sendNotification(payload);
+            logger_1.logger.debug('🔗 Webhook notification sent successfully');
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Failed to send webhook notification:', error);
+        }
+    }
+    async sendNotification(payload) {
+        await axios_1.default.post(this.url, payload, {
+            headers: this.headers,
+            timeout: 10000
+        });
+    }
+    async finalize() {
+        // Nothing to finalize for webhook
+    }
+}
+exports.WebhookOutput = WebhookOutput;

package/dist/protocols/base.d.ts

@@ -0,0 +1,33 @@
+import { VUContext } from '../config/types';
+export interface ProtocolResult {
+    success: boolean;
+    status?: number;
+    status_text?: string;
+    error?: string;
+    error_code?: string;
+    data?: any;
+    response_size?: number;
+    response_time?: number;
+    duration?: number;
+    shouldRecord?: boolean;
+    request_url?: string;
+    request_method?: string;
+    request_headers?: Record<string, string>;
+    request_body?: string;
+    response_headers?: Record<string, string>;
+    response_body?: string;
+    sample_start?: number;
+    connect_time?: number;
+    latency?: number;
+    sent_bytes?: number;
+    headers_size_sent?: number;
+    body_size_sent?: number;
+    headers_size_received?: number;
+    body_size_received?: number;
+    data_type?: 'text' | 'bin' | '';
+    custom_metrics?: Record<string, any>;
+}
+export interface ProtocolHandler {
+    execute(action: any, context: VUContext): Promise<ProtocolResult>;
+    cleanup?(): Promise<void>;
+}

package/dist/protocols/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/protocols/rest/handler.d.ts

@@ -0,0 +1,67 @@
+import { ProtocolHandler, ProtocolResult } from '../base';
+import { VUContext, RESTStep, DebugConfig } from '../../config/types';
+export declare class RESTHandler implements ProtocolHandler {
+    private axiosInstance;
+    private debugConfig?;
+    private connectionTimings;
+    constructor(baseURL?: string, defaultHeaders?: Record<string, string>, timeout?: number, debugConfig?: DebugConfig);
+    execute(request: RESTStep, context: VUContext): Promise<ProtocolResult>;
+    private prepareRequestConfig;
+    /**
+     * Handle authentication configuration
+     */
+    private handleAuthentication;
+    /**
+     * Check if Content-Type header is already set (case-insensitive)
+     */
+    private hasContentTypeHeader;
+    /**
+     * Process body payload and detect content type
+     */
+    private processBodyPayload;
+    /**
+     * Detect if string is valid JSON
+     */
+    private isJsonString;
+    /**
+     * Detect if string is XML
+     */
+    private isXmlString;
+    /**
+     * Check if body contains template expressions
+     */
+    private isTemplateString;
+    /**
+     * Detect content type from template file extension or content
+     */
+    private detectTemplateContentType;
+    private createSuccessResult;
+    private handleError;
+    private addDetailedInfo;
+    private logRequestDetails;
+    private logResponseDetails;
+    private runChecksOptimized;
+    private buildURL;
+    private getResponseText;
+    private getJsonPathOptimized;
+    private flattenHeaders;
+    private truncateIfNeeded;
+    private shouldCaptureDetails;
+    /**
+     * Calculate request header and body sizes
+     */
+    private calculateRequestSizes;
+    /**
+     * Calculate response header and body sizes
+     */
+    private calculateResponseSizes;
+    /**
+     * Detect data type from response
+     */
+    private detectDataType;
+    /**
+     * Generate JMeter-style thread name
+     * Format: "iteration. step_name vu_id-iteration"
+     */
+    private generateThreadName;
+}