@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/metrics/core/error-tracker.d.ts

@@ -0,0 +1,9 @@
+import { ErrorDetail, TestResult } from '../types';
+export declare class ErrorTracker {
+    private errorDetails;
+    clear(): void;
+    trackError(result: TestResult): void;
+    getErrorDetails(): ErrorDetail[];
+    getErrorDistribution(results: TestResult[]): Record<string, number>;
+    getStatusDistribution(results: TestResult[]): Record<number, number>;
+}

package/dist/metrics/core/error-tracker.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorTracker = void 0;
+class ErrorTracker {
+    constructor() {
+        this.errorDetails = new Map();
+    }
+    clear() {
+        this.errorDetails.clear();
+    }
+    trackError(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
+            });
+        }
+    }
+    getErrorDetails() {
+        return Array.from(this.errorDetails.values()).sort((a, b) => b.count - a.count);
+    }
+    getErrorDistribution(results) {
+        const distribution = {};
+        results.filter(r => !r.success).forEach(r => {
+            const error = r.error || 'Unknown error';
+            distribution[error] = (distribution[error] || 0) + 1;
+        });
+        return distribution;
+    }
+    getStatusDistribution(results) {
+        const distribution = {};
+        results.forEach(r => {
+            if (r.status) {
+                distribution[r.status] = (distribution[r.status] || 0) + 1;
+            }
+        });
+        return distribution;
+    }
+}
+exports.ErrorTracker = ErrorTracker;

package/dist/metrics/core/index.d.ts

@@ -0,0 +1,3 @@
+export { StatisticsEngine, RunningStats } from './statistics-engine';
+export { ErrorTracker } from './error-tracker';
+export { ResultStorage } from './result-storage';

package/dist/metrics/core/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultStorage = exports.ErrorTracker = exports.StatisticsEngine = void 0;
+var statistics_engine_1 = require("./statistics-engine");
+Object.defineProperty(exports, "StatisticsEngine", { enumerable: true, get: function () { return statistics_engine_1.StatisticsEngine; } });
+var error_tracker_1 = require("./error-tracker");
+Object.defineProperty(exports, "ErrorTracker", { enumerable: true, get: function () { return error_tracker_1.ErrorTracker; } });
+var result_storage_1 = require("./result-storage");
+Object.defineProperty(exports, "ResultStorage", { enumerable: true, get: function () { return result_storage_1.ResultStorage; } });

package/dist/metrics/core/result-storage.d.ts

@@ -0,0 +1,19 @@
+import { TestResult, VUStartEvent } from '../types';
+export declare class ResultStorage {
+    private results;
+    private vuStartEvents;
+    private loadPatternType;
+    private readonly maxStoredResults;
+    constructor(maxStoredResults?: number);
+    clear(): void;
+    setLoadPatternType(pattern: string): void;
+    recordVUStart(vuId: number): void;
+    addResult(result: TestResult): boolean;
+    getResults(): TestResult[];
+    getVUStartEvents(): VUStartEvent[];
+    getResultCount(): number;
+    isAtCapacity(): boolean;
+    getResponseSizes(): number[];
+    getActiveVUsAtTime(time: number): number;
+    getResultsInInterval(startTime: number, endTime: number): TestResult[];
+}

package/dist/metrics/core/result-storage.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultStorage = void 0;
+class ResultStorage {
+    constructor(maxStoredResults = 50000) {
+        this.results = [];
+        this.vuStartEvents = [];
+        this.loadPatternType = 'basic';
+        this.maxStoredResults = maxStoredResults;
+    }
+    clear() {
+        this.results = [];
+        this.vuStartEvents = [];
+    }
+    setLoadPatternType(pattern) {
+        this.loadPatternType = pattern;
+    }
+    recordVUStart(vuId) {
+        this.vuStartEvents.push({
+            vu_id: vuId,
+            start_time: Date.now(),
+            load_pattern: this.loadPatternType
+        });
+    }
+    addResult(result) {
+        if (this.results.length < this.maxStoredResults) {
+            this.results.push(result);
+            return true;
+        }
+        return false;
+    }
+    getResults() {
+        return [...this.results];
+    }
+    getVUStartEvents() {
+        return [...this.vuStartEvents];
+    }
+    getResultCount() {
+        return this.results.length;
+    }
+    isAtCapacity() {
+        return this.results.length >= this.maxStoredResults;
+    }
+    getResponseSizes() {
+        return this.results
+            .filter(r => r.response_size)
+            .map(r => r.response_size);
+    }
+    getActiveVUsAtTime(time) {
+        return this.vuStartEvents.filter(vu => vu.start_time <= time).length;
+    }
+    getResultsInInterval(startTime, endTime) {
+        return this.results.filter(r => r.timestamp >= startTime && r.timestamp < endTime);
+    }
+}
+exports.ResultStorage = ResultStorage;

package/dist/metrics/core/statistics-engine.d.ts

@@ -0,0 +1,27 @@
+export interface RunningStats {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    totalDuration: number;
+    minDuration: number;
+    maxDuration: number;
+    durations: number[];
+}
+export declare class StatisticsEngine {
+    private readonly maxDurationsForPercentiles;
+    private stats;
+    constructor(maxDurationsForPercentiles?: number);
+    private createEmptyStats;
+    reset(): void;
+    recordResult(duration: number, success: boolean): void;
+    getStats(): RunningStats;
+    getAverageResponseTime(): number;
+    getMinDuration(): number;
+    getMaxDuration(): number;
+    getDurations(): number[];
+    calculatePercentiles(values?: number[]): Record<number, number>;
+    getSuccessRate(): number;
+    getTotalRequests(): number;
+    getSuccessfulRequests(): number;
+    getFailedRequests(): number;
+}

package/dist/metrics/core/statistics-engine.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatisticsEngine = void 0;
+class StatisticsEngine {
+    constructor(maxDurationsForPercentiles = 10000) {
+        this.maxDurationsForPercentiles = maxDurationsForPercentiles;
+        this.stats = this.createEmptyStats();
+    }
+    createEmptyStats() {
+        return {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalDuration: 0,
+            minDuration: Infinity,
+            maxDuration: 0,
+            durations: []
+        };
+    }
+    reset() {
+        this.stats = this.createEmptyStats();
+    }
+    recordResult(duration, success) {
+        this.stats.totalRequests++;
+        if (success) {
+            this.stats.successfulRequests++;
+            this.stats.totalDuration += duration;
+            this.stats.minDuration = Math.min(this.stats.minDuration, duration);
+            this.stats.maxDuration = Math.max(this.stats.maxDuration, duration);
+            // Keep limited durations for percentile calculation (reservoir sampling)
+            if (this.stats.durations.length < this.maxDurationsForPercentiles) {
+                this.stats.durations.push(duration);
+            }
+            else {
+                // Randomly replace an existing duration (reservoir sampling)
+                const replaceIndex = Math.floor(Math.random() * this.stats.totalRequests);
+                if (replaceIndex < this.maxDurationsForPercentiles) {
+                    this.stats.durations[replaceIndex] = duration;
+                }
+            }
+        }
+        else {
+            this.stats.failedRequests++;
+        }
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    getAverageResponseTime() {
+        return this.stats.successfulRequests > 0
+            ? this.stats.totalDuration / this.stats.successfulRequests
+            : 0;
+    }
+    getMinDuration() {
+        return this.stats.minDuration === Infinity ? 0 : this.stats.minDuration;
+    }
+    getMaxDuration() {
+        return this.stats.maxDuration;
+    }
+    getDurations() {
+        return [...this.stats.durations];
+    }
+    calculatePercentiles(values) {
+        const durations = values || this.stats.durations;
+        if (durations.length === 0)
+            return {};
+        const sorted = [...durations].sort((a, b) => a - b);
+        const percentileValues = [50, 90, 95, 99, 99.9, 99.99];
+        const result = {};
+        percentileValues.forEach(p => {
+            const index = Math.ceil((p / 100) * sorted.length) - 1;
+            result[p] = sorted[Math.max(0, index)];
+        });
+        return result;
+    }
+    getSuccessRate() {
+        return this.stats.totalRequests > 0
+            ? (this.stats.successfulRequests / this.stats.totalRequests) * 100
+            : 0;
+    }
+    getTotalRequests() {
+        return this.stats.totalRequests;
+    }
+    getSuccessfulRequests() {
+        return this.stats.successfulRequests;
+    }
+    getFailedRequests() {
+        return this.stats.failedRequests;
+    }
+}
+exports.StatisticsEngine = StatisticsEngine;

package/dist/metrics/output/file-writer.d.ts

@@ -0,0 +1,19 @@
+import { TestResult } from '../types';
+export interface FileOutputConfig {
+    enabled: boolean;
+    path: string;
+    format: 'jsonl' | 'csv';
+}
+export interface IncrementalFilesConfig {
+    enabled: boolean;
+    jsonPath?: string;
+}
+export declare class FileWriter {
+    private incrementalConfig;
+    initialize(config: IncrementalFilesConfig): Promise<void>;
+    reset(): void;
+    writeBatchToFile(batch: TestResult[], config: FileOutputConfig, batchNumber: number): Promise<void>;
+    private formatBatchAsCSV;
+    updateIncrementalFiles(batch: TestResult[]): Promise<void>;
+    private updateIncrementalJSON;
+}

package/dist/metrics/output/file-writer.js

@@ -0,0 +1,129 @@
+"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.FileWriter = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger_1 = require("../../utils/logger");
+class FileWriter {
+    constructor() {
+        this.incrementalConfig = null;
+    }
+    async initialize(config) {
+        this.incrementalConfig = config;
+        if (!config.enabled)
+            return;
+        try {
+            // Initialize JSON file
+            if (config.jsonPath) {
+                const dir = path.dirname(config.jsonPath);
+                await fs.mkdir(dir, { recursive: true });
+                await fs.writeFile(config.jsonPath, '[]');
+                logger_1.logger.debug(`Initialized incremental JSON file: ${config.jsonPath}`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to initialize incremental files:', error);
+        }
+    }
+    reset() {
+        // No state to reset
+    }
+    async writeBatchToFile(batch, config, batchNumber) {
+        if (!config.enabled)
+            return;
+        try {
+            const dir = path.dirname(config.path);
+            await fs.mkdir(dir, { recursive: true });
+            let content;
+            if (config.format === 'csv') {
+                content = this.formatBatchAsCSV(batch, batchNumber);
+            }
+            else {
+                // JSONL format (default)
+                content = batch.map(result => JSON.stringify({
+                    ...result,
+                    timestamp: new Date(result.timestamp).toISOString(),
+                    batch_number: batchNumber
+                })).join('\n') + '\n';
+            }
+            await fs.appendFile(config.path, content);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to write batch to file:', error);
+        }
+    }
+    formatBatchAsCSV(batch, batchNumber) {
+        return batch.map(result => [
+            new Date(result.timestamp).toISOString(),
+            batchNumber,
+            result.vu_id,
+            result.scenario,
+            result.action,
+            result.step_name || '',
+            result.duration,
+            result.success,
+            result.status || '',
+            (result.error || '').replace(/"/g, '""')
+        ].join(',')).join('\n') + '\n';
+    }
+    async updateIncrementalFiles(batch) {
+        if (!this.incrementalConfig?.enabled)
+            return;
+        try {
+            if (this.incrementalConfig.jsonPath) {
+                await this.updateIncrementalJSON(batch, this.incrementalConfig.jsonPath);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to update incremental files:', error);
+        }
+    }
+    async updateIncrementalJSON(batch, filePath) {
+        try {
+            const existingContent = await fs.readFile(filePath, 'utf8');
+            let existingData = [];
+            if (existingContent.trim()) {
+                existingData = JSON.parse(existingContent);
+            }
+            const updatedData = [...existingData, ...batch];
+            await fs.writeFile(filePath, JSON.stringify(updatedData, null, 2));
+        }
+        catch (error) {
+            await fs.writeFile(filePath, JSON.stringify(batch, null, 2));
+        }
+    }
+}
+exports.FileWriter = FileWriter;

package/dist/metrics/output/index.d.ts

@@ -0,0 +1,2 @@
+export { FileWriter, FileOutputConfig, IncrementalFilesConfig } from './file-writer';
+export { InfluxDBWriter, InfluxDBWriterConfig, TestMetricsQueryOptions, getInfluxDBWriter, setInfluxDBWriter, initInfluxDBWriter } from './influxdb-writer';

package/dist/metrics/output/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initInfluxDBWriter = exports.setInfluxDBWriter = exports.getInfluxDBWriter = exports.InfluxDBWriter = exports.FileWriter = void 0;
+var file_writer_1 = require("./file-writer");
+Object.defineProperty(exports, "FileWriter", { enumerable: true, get: function () { return file_writer_1.FileWriter; } });
+var influxdb_writer_1 = require("./influxdb-writer");
+Object.defineProperty(exports, "InfluxDBWriter", { enumerable: true, get: function () { return influxdb_writer_1.InfluxDBWriter; } });
+Object.defineProperty(exports, "getInfluxDBWriter", { enumerable: true, get: function () { return influxdb_writer_1.getInfluxDBWriter; } });
+Object.defineProperty(exports, "setInfluxDBWriter", { enumerable: true, get: function () { return influxdb_writer_1.setInfluxDBWriter; } });
+Object.defineProperty(exports, "initInfluxDBWriter", { enumerable: true, get: function () { return influxdb_writer_1.initInfluxDBWriter; } });

package/dist/metrics/output/influxdb-writer.d.ts

@@ -0,0 +1,89 @@
+import { TestResult, MetricsSummary, CapturedNetworkCall } from '../types';
+export interface InfluxDBWriterConfig {
+    url: string;
+    token: string;
+    org: string;
+    bucket: string;
+    /** Batch size for writing points (default: 100) */
+    batchSize?: number;
+    /** Flush interval in ms (default: 1000) */
+    flushInterval?: number;
+}
+export interface TestMetricsQueryOptions {
+    testId?: string;
+    testName?: string;
+    startTime?: Date;
+    endTime?: Date;
+    scenario?: string;
+    limit?: number;
+}
+/**
+ * InfluxDB writer for test metrics (response times, network calls, etc.)
+ * This is optional - test results can still be stored as JSON files.
+ */
+export declare class InfluxDBWriter {
+    private client;
+    private writeApi;
+    private queryApi;
+    private config;
+    private enabled;
+    private currentTestId;
+    private currentTestName;
+    constructor(config?: Partial<InfluxDBWriterConfig>);
+    connect(): Promise<boolean>;
+    isEnabled(): boolean;
+    /**
+     * Start a new test run - sets the test ID and name for all subsequent writes
+     */
+    startTest(testId: string, testName: string): void;
+    /**
+     * Write a single test result to InfluxDB
+     */
+    writeResult(result: TestResult): Promise<void>;
+    /**
+     * Write a batch of test results to InfluxDB
+     */
+    writeBatch(results: TestResult[]): Promise<void>;
+    /**
+     * Write a network call to InfluxDB
+     */
+    writeNetworkCall(call: CapturedNetworkCall): Promise<void>;
+    /**
+     * Write test summary to InfluxDB
+     */
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    /**
+     * Query test results from InfluxDB
+     */
+    queryResults(options?: TestMetricsQueryOptions): Promise<TestResult[]>;
+    /**
+     * Query network calls from InfluxDB
+     */
+    queryNetworkCalls(options?: TestMetricsQueryOptions): Promise<CapturedNetworkCall[]>;
+    /**
+     * Get list of test runs
+     */
+    getTestRuns(limit?: number): Promise<Array<{
+        testId: string;
+        testName: string;
+        timestamp: Date;
+    }>>;
+    /**
+     * Export test data for a specific test run
+     */
+    exportTestData(testId: string, format?: 'json' | 'csv'): Promise<string>;
+    /**
+     * Finalize the current test - flush all pending writes
+     */
+    finalize(): Promise<void>;
+    /**
+     * Close the connection
+     */
+    close(): Promise<void>;
+    private rowsToResults;
+    private rowsToNetworkCalls;
+    private resultsToCSV;
+}
+export declare function getInfluxDBWriter(): InfluxDBWriter | null;
+export declare function setInfluxDBWriter(writer: InfluxDBWriter): void;
+export declare function initInfluxDBWriter(config?: Partial<InfluxDBWriterConfig>): Promise<InfluxDBWriter>;