@testsmith/perfornium 0.1.0

package/dist/metrics/types.d.ts

@@ -0,0 +1,135 @@
+export interface TestResult {
+    shouldRecord?: any;
+    id?: string;
+    vu_id: number;
+    iteration?: number;
+    scenario: string;
+    name?: string;
+    action?: string;
+    step_name?: string;
+    thread_name?: string;
+    timestamp: number;
+    sample_start?: number;
+    duration?: number;
+    response_time?: number;
+    success: boolean;
+    status?: number;
+    status_text?: string;
+    error?: string;
+    error_code?: string;
+    response_size?: number;
+    response_headers?: Record<string, string>;
+    response_body?: string;
+    request_url?: string;
+    request_method?: string;
+    request_headers?: Record<string, string>;
+    request_body?: string;
+    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 VUStartEvent {
+    vu_id: number;
+    start_time: number;
+    load_pattern: string;
+}
+export interface StepStatistics {
+    step_name: string;
+    scenario: string;
+    total_requests: number;
+    successful_requests: number;
+    failed_requests: number;
+    success_rate: number;
+    avg_response_time: number;
+    min_response_time: number;
+    max_response_time: number;
+    percentiles: Record<number, number>;
+    response_times: number[];
+    error_distribution: Record<string, number>;
+    status_distribution: Record<number, number>;
+}
+export interface TestSummary {
+    total_requests: number;
+    successful_requests: number;
+    failed_requests: number;
+    success_rate: number;
+    avg_response_time: number;
+    min_response_time: number;
+    max_response_time: number;
+    percentiles: Record<string, number>;
+    requests_per_second: number;
+    bytes_per_second: number;
+    bytes_received?: number;
+    total_duration: number;
+    error_distribution?: Record<string, number>;
+    status_distribution: Record<number, number>;
+    error_details: ErrorDetail[];
+}
+export interface MetricsSummary {
+    total_requests: number;
+    successful_requests: number;
+    failed_requests: number;
+    success_rate: number;
+    avg_response_time: number;
+    min_response_time: number;
+    max_response_time: number;
+    percentiles: Record<number, number>;
+    requests_per_second: number;
+    bytes_per_second: number;
+    total_duration: number;
+    error_distribution: Record<string, number>;
+    status_distribution: Record<number, number>;
+    error_details: ErrorDetail[];
+    step_statistics: StepStatistics[];
+    vu_ramp_up: VUStartEvent[];
+    timeline_data: TimelineData[];
+    web_vitals_data?: {
+        lcp?: number;
+        fid?: number;
+        cls?: number;
+        fcp?: number;
+        ttfb?: number;
+        tti?: number;
+        tbt?: number;
+        speedIndex?: number;
+    };
+    vitals_score?: 'good' | 'needs-improvement' | 'poor';
+    vitals_details?: Record<string, {
+        value: number;
+        score: 'good' | 'needs-improvement' | 'poor';
+    }>;
+    verification_metrics?: {
+        total_verifications: number;
+        success_rate: number;
+        average_duration: number;
+        p95_duration: number;
+        slowest_step: any;
+        fastest_step: any;
+    };
+}
+export interface TimelineData {
+    timestamp: number;
+    time_label: string;
+    active_vus: number;
+    requests_count: number;
+    avg_response_time: number;
+    success_rate: number;
+    throughput: number;
+}
+export interface ErrorDetail {
+    timestamp: number;
+    vu_id: number;
+    scenario: string;
+    action: string;
+    status?: number;
+    error: string;
+    request_url?: string;
+    response_body?: string;
+    count: number;
+}

package/dist/metrics/types.js

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

package/dist/outputs/base.d.ts

@@ -0,0 +1,7 @@
+import { TestResult, MetricsSummary } from '../metrics/types';
+export interface OutputHandler {
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+}

package/dist/outputs/base.js

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

package/dist/outputs/csv.d.ts

@@ -0,0 +1,13 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export declare class CSVOutput implements OutputHandler {
+    private filePath;
+    private csvWriter;
+    private results;
+    constructor(filePath: string);
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    private transformResult;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+}

package/dist/outputs/csv.js

@@ -0,0 +1,163 @@
+"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.CSVOutput = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const csv_writer_1 = require("csv-writer");
+class CSVOutput {
+    constructor(filePath) {
+        this.results = [];
+        this.filePath = filePath;
+    }
+    async initialize() {
+        // Ensure directory exists
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        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: 'action', title: 'action' },
+                { id: 'step_name', title: 'step_name' },
+                { id: 'duration', title: 'duration_ms' },
+                { id: 'success', title: 'success' },
+                { id: 'status', title: 'http_status' },
+                { id: 'error', title: 'error' },
+                { id: 'response_size', title: 'response_size_bytes' },
+                // JMeter-style metrics
+                { id: 'latency', title: 'latency_ms' },
+                { id: 'connect_time', title: 'connect_time_ms' },
+                { id: 'sent_bytes', title: 'sent_bytes' },
+                { id: 'data_type', title: 'data_type' },
+                // Web Vitals columns
+                { id: 'lcp', title: 'lcp_ms' },
+                { id: 'cls', title: 'cls_score' },
+                { id: 'inp', title: 'inp_ms' },
+                { id: 'ttfb', title: 'ttfb_ms' },
+                { id: 'fcp', title: 'fcp_ms' },
+                { id: 'fid', title: 'fid_ms' },
+                { id: 'vitals_score', title: 'vitals_score' },
+                // Verification metrics
+                { id: 'verification_duration', title: 'verification_duration_ms' },
+                { id: 'verification_success', title: 'verification_success' },
+                { id: 'verification_step_name', title: 'verification_step_name' },
+                // Page info
+                { id: 'page_url', title: 'page_url' },
+                { id: 'page_title', title: 'page_title' }
+            ]
+        });
+    }
+    async writeResult(result) {
+        // Write immediately to file (incremental during test)
+        this.results.push(result); // Keep for finalize summary
+        // Transform and write single result
+        const record = this.transformResult(result);
+        await this.csvWriter.writeRecords([record]);
+    }
+    transformResult(result) {
+        return {
+            timestamp: result.timestamp,
+            vu_id: result.vu_id,
+            iteration: result.iteration,
+            scenario: result.scenario,
+            action: result.action,
+            step_name: result.step_name || result.action,
+            duration: result.duration,
+            success: result.success,
+            status: result.status,
+            error: result.error || '',
+            response_size: result.response_size || 0,
+            // JMeter-style metrics
+            latency: result.latency || 0,
+            connect_time: result.connect_time || 0,
+            sent_bytes: result.sent_bytes || 0,
+            data_type: result.data_type || '',
+            // Web Vitals
+            lcp: result.custom_metrics?.web_vitals?.lcp || null,
+            cls: result.custom_metrics?.web_vitals?.cls || null,
+            inp: result.custom_metrics?.web_vitals?.inp || null,
+            ttfb: result.custom_metrics?.web_vitals?.ttfb || null,
+            fcp: result.custom_metrics?.web_vitals?.fcp || null,
+            fid: result.custom_metrics?.web_vitals?.fid || null,
+            vitals_score: result.custom_metrics?.web_vitals?.score || null,
+            // Verification
+            verification_duration: result.custom_metrics?.verification?.duration || null,
+            verification_success: result.custom_metrics?.verification?.success || null,
+            verification_step_name: result.custom_metrics?.verification?.step_name || null,
+            // Page info
+            page_url: result.custom_metrics?.page_url || null,
+            page_title: result.custom_metrics?.page_title || null
+        };
+    }
+    async writeSummary(summary) {
+        // Summary will be written to a 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' }
+            ]
+        });
+        const summaryData = [
+            { metric: 'total_requests', value: summary.total_requests, unit: 'count' },
+            { metric: 'successful_requests', value: summary.successful_requests, unit: 'count' },
+            { metric: 'failed_requests', value: summary.failed_requests, unit: 'count' },
+            { metric: 'success_rate', value: summary.success_rate.toFixed(2), unit: 'percent' },
+            { metric: 'avg_response_time', value: summary.avg_response_time.toFixed(2), unit: 'ms' },
+            { metric: 'min_response_time', value: summary.min_response_time, unit: 'ms' },
+            { metric: 'max_response_time', value: summary.max_response_time, unit: 'ms' },
+            { metric: 'requests_per_second', value: summary.requests_per_second.toFixed(2), unit: 'req/s' },
+            { metric: 'total_duration', value: summary.total_duration, unit: 'ms' },
+            { metric: 'p50_response_time', value: summary.percentiles[50] || 0, unit: 'ms' },
+            { metric: 'p90_response_time', value: summary.percentiles[90] || 0, unit: 'ms' },
+            { metric: 'p95_response_time', value: summary.percentiles[95] || 0, unit: 'ms' },
+            { metric: 'p99_response_time', value: summary.percentiles[99] || 0, unit: 'ms' }
+        ];
+        await summaryWriter.writeRecords(summaryData);
+    }
+    async finalize() {
+        // Results already written incrementally during test
+        // No need to write them again
+    }
+}
+exports.CSVOutput = CSVOutput;

package/dist/outputs/graphite.d.ts

@@ -0,0 +1,13 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export declare class GraphiteOutput implements OutputHandler {
+    private host;
+    private port;
+    private prefix;
+    private client?;
+    constructor(host?: string, port?: number, prefix?: string);
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+}

package/dist/outputs/graphite.js

@@ -0,0 +1,126 @@
+"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.GraphiteOutput = void 0;
+const net = __importStar(require("net"));
+const logger_1 = require("../utils/logger");
+class GraphiteOutput {
+    constructor(host = 'localhost', port = 2003, prefix = 'perfornium') {
+        this.host = host;
+        this.port = port;
+        this.prefix = prefix;
+    }
+    async initialize() {
+        try {
+            this.client = new net.Socket();
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Graphite connection timeout'));
+                }, 5000);
+                this.client.connect(this.port, this.host, () => {
+                    clearTimeout(timeout);
+                    logger_1.logger.debug(`📊 Connected to Graphite at ${this.host}:${this.port}`);
+                    resolve();
+                });
+                this.client.on('error', (error) => {
+                    clearTimeout(timeout);
+                    logger_1.logger.warn('⚠️  Graphite connection error:', error);
+                    reject(error);
+                });
+            });
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Failed to connect to Graphite:', error);
+            throw error;
+        }
+    }
+    async writeResult(result) {
+        if (!this.client || this.client.destroyed) {
+            return; // Skip if not connected
+        }
+        try {
+            const timestamp = Math.floor(result.timestamp / 1000);
+            const metricPrefix = `${this.prefix}.${result.scenario}.${result.action}`;
+            const metrics = [
+                `${metricPrefix}.duration ${result.duration} ${timestamp}`,
+                `${metricPrefix}.success ${result.success ? 1 : 0} ${timestamp}`
+            ];
+            if (result.status) {
+                metrics.push(`${metricPrefix}.status ${result.status} ${timestamp}`);
+            }
+            if (result.response_size) {
+                metrics.push(`${metricPrefix}.response_size ${result.response_size} ${timestamp}`);
+            }
+            const data = metrics.join('\n') + '\n';
+            this.client.write(data);
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Failed to write to Graphite:', error);
+        }
+    }
+    async writeSummary(summary) {
+        if (!this.client || this.client.destroyed) {
+            return;
+        }
+        try {
+            const timestamp = Math.floor(Date.now() / 1000);
+            const summaryPrefix = `${this.prefix}.summary`;
+            const metrics = [
+                `${summaryPrefix}.total_requests ${summary.total_requests} ${timestamp}`,
+                `${summaryPrefix}.successful_requests ${summary.successful_requests} ${timestamp}`,
+                `${summaryPrefix}.failed_requests ${summary.failed_requests} ${timestamp}`,
+                `${summaryPrefix}.success_rate ${summary.success_rate} ${timestamp}`,
+                `${summaryPrefix}.avg_response_time ${summary.avg_response_time} ${timestamp}`,
+                `${summaryPrefix}.requests_per_second ${summary.requests_per_second} ${timestamp}`,
+                `${summaryPrefix}.total_duration ${summary.total_duration} ${timestamp}`
+            ];
+            // Add percentiles
+            Object.entries(summary.percentiles).forEach(([percentile, value]) => {
+                metrics.push(`${summaryPrefix}.p${percentile} ${value} ${timestamp}`);
+            });
+            const data = metrics.join('\n') + '\n';
+            this.client.write(data);
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Failed to write summary to Graphite:', error);
+        }
+    }
+    async finalize() {
+        if (this.client && !this.client.destroyed) {
+            this.client.end();
+        }
+    }
+}
+exports.GraphiteOutput = GraphiteOutput;

package/dist/outputs/influxdb.d.ts

@@ -0,0 +1,12 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export declare class InfluxDBOutput implements OutputHandler {
+    private client;
+    private database;
+    private tags;
+    constructor(url: string, database: string, tags?: Record<string, string>);
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+}

package/dist/outputs/influxdb.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfluxDBOutput = void 0;
+const influx_1 = require("influx");
+const logger_1 = require("../utils/logger");
+class InfluxDBOutput {
+    constructor(url, database, tags = {}) {
+        this.client = new influx_1.InfluxDB(url);
+        this.database = database;
+        this.tags = tags;
+    }
+    async initialize() {
+        try {
+            const databases = await this.client.getDatabaseNames();
+            if (!databases.includes(this.database)) {
+                await this.client.createDatabase(this.database);
+            }
+            logger_1.logger.debug(`📊 InfluxDB output initialized: ${this.database}`);
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Could not initialize InfluxDB:', error);
+            throw error;
+        }
+    }
+    async writeResult(result) {
+        try {
+            const point = {
+                measurement: 'performance_test',
+                tags: {
+                    ...this.tags,
+                    scenario: result.scenario,
+                    action: result.action,
+                    success: result.success.toString(),
+                    vu_id: result.vu_id.toString()
+                },
+                fields: {
+                    duration: result.duration,
+                    response_size: result.response_size || 0,
+                    status: result.status || 0
+                },
+                timestamp: new Date(result.timestamp)
+            };
+            if (result.error) {
+                point.tags.error = result.error;
+            }
+            await this.client.writePoints([point], { database: this.database });
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Could not write to InfluxDB:', error);
+        }
+    }
+    async writeSummary(summary) {
+        try {
+            const summaryPoints = [
+                {
+                    measurement: 'test_summary',
+                    tags: this.tags,
+                    fields: {
+                        total_requests: summary.total_requests,
+                        successful_requests: summary.successful_requests,
+                        failed_requests: summary.failed_requests,
+                        success_rate: summary.success_rate,
+                        avg_response_time: summary.avg_response_time,
+                        min_response_time: summary.min_response_time,
+                        max_response_time: summary.max_response_time,
+                        requests_per_second: summary.requests_per_second,
+                        total_duration: summary.total_duration
+                    },
+                    timestamp: new Date()
+                }
+            ];
+            await this.client.writePoints(summaryPoints, { database: this.database });
+        }
+        catch (error) {
+            logger_1.logger.warn('⚠️  Could not write summary to InfluxDB:', error);
+        }
+    }
+    async finalize() {
+        // InfluxDB doesn't need explicit finalization
+    }
+}
+exports.InfluxDBOutput = InfluxDBOutput;

package/dist/outputs/json.d.ts

@@ -0,0 +1,14 @@
+import { OutputHandler } from './base';
+import { TestResult, MetricsSummary } from '../metrics/types';
+export declare class JSONOutput implements OutputHandler {
+    private filePath;
+    private results;
+    private summary?;
+    private fileStream?;
+    private firstWrite;
+    constructor(filePath: string);
+    initialize(): Promise<void>;
+    writeResult(result: TestResult): Promise<void>;
+    writeSummary(summary: MetricsSummary): Promise<void>;
+    finalize(): Promise<void>;
+}