@testsmith/perfornium 0.6.4 → 0.6.6

package/dist/dashboard/templates/styles.css

@@ -0,0 +1,402 @@
+:root {
+  --bg-primary: #0f0f23;
+  --bg-secondary: #1a1a2e;
+  --bg-card: rgba(255, 255, 255, 0.03);
+  --border: rgba(255, 255, 255, 0.1);
+  --text-primary: #e2e8f0;
+  --text-secondary: #9ca3af;
+  --accent-cyan: #00d4ff;
+  --accent-purple: #9c40ff;
+  --success: #22c55e;
+  --warning: #eab308;
+  --error: #ef4444;
+}
+
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  min-height: 100vh;
+}
+
+/* Header */
+.header {
+  background: linear-gradient(135deg, rgba(0, 212, 255, 0.1), rgba(156, 64, 255, 0.1));
+  border-bottom: 1px solid var(--border);
+  padding: 16px 24px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  position: sticky;
+  top: 0;
+  z-index: 100;
+  backdrop-filter: blur(10px);
+}
+
+.logo {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  font-size: 22px;
+  font-weight: 700;
+  color: white;
+}
+
+.logo svg { width: 36px; height: 36px; }
+
+/* Container */
+.container { max-width: 1800px; margin: 0 auto; padding: 24px; }
+
+/* Tabs */
+.tabs { display: flex; gap: 8px; margin-bottom: 24px; flex-wrap: wrap; }
+
+.tab {
+  padding: 10px 20px;
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition: all 0.2s;
+  font-size: 14px;
+  font-weight: 500;
+}
+
+.tab:hover { border-color: var(--accent-cyan); color: white; }
+.tab.active {
+  background: linear-gradient(135deg, var(--accent-cyan), var(--accent-purple));
+  border-color: transparent;
+  color: white;
+}
+
+/* Panels */
+.panel { display: none; }
+.panel.active { display: block; }
+
+/* Grid layouts */
+.grid-2 { display: grid; grid-template-columns: repeat(2, 1fr); gap: 20px; grid-auto-flow: dense; }
+.grid-3 { display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px; grid-auto-flow: dense; }
+.grid-4 { display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; grid-auto-flow: dense; }
+.grid-6 { display: grid; grid-template-columns: repeat(6, 1fr); gap: 16px; grid-auto-flow: dense; }
+
+@media (max-width: 1400px) { .grid-6 { grid-template-columns: repeat(3, 1fr); } }
+@media (max-width: 1200px) { .grid-3 { grid-template-columns: repeat(2, 1fr); } }
+@media (max-width: 900px) {
+  .grid-2, .grid-3 { grid-template-columns: 1fr; }
+  .grid-4, .grid-6 { grid-template-columns: repeat(2, 1fr); }
+}
+
+/* Cards */
+.card {
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 20px;
+  margin-bottom: 20px;
+}
+
+.card-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 16px;
+}
+
+.card h3 { font-size: 16px; font-weight: 600; color: var(--accent-cyan); }
+.card-full { grid-column: 1 / -1; }
+
+/* Metric cards */
+.metric-card {
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 16px;
+  text-align: center;
+}
+
+.metric-card .value {
+  font-size: 28px;
+  font-weight: 700;
+  background: linear-gradient(135deg, var(--accent-cyan), var(--accent-purple));
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+.metric-card .label {
+  font-size: 12px;
+  color: var(--text-secondary);
+  margin-top: 4px;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+.metric-card .change { font-size: 11px; margin-top: 4px; }
+.metric-card .change.up { color: var(--error); }
+.metric-card .change.down { color: var(--success); }
+
+/* Charts */
+.chart-container { position: relative; height: 280px; width: 100%; }
+.chart-container.tall { height: 380px; }
+.chart-container.short { height: 200px; }
+.chart-container canvas { display: block; }
+
+/* Expandable chart cards */
+.card.expandable {
+  position: relative;
+}
+.card.expandable .expand-btn {
+  position: absolute;
+  top: 12px;
+  right: 12px;
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  opacity: 0;
+  transition: opacity 0.2s, background 0.2s, color 0.2s;
+  z-index: 10;
+}
+.card.expandable:hover .expand-btn {
+  opacity: 1;
+}
+.card.expandable .expand-btn:hover {
+  background: var(--bg-tertiary);
+  color: var(--text-primary);
+  border-color: var(--primary);
+}
+.card.expandable .expand-btn svg {
+  width: 16px;
+  height: 16px;
+}
+/* Chart Modal */
+.chart-modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.85);
+  z-index: 1000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 40px;
+  opacity: 0;
+  visibility: hidden;
+  transition: opacity 0.2s, visibility 0.2s;
+}
+.chart-modal-overlay.active {
+  opacity: 1;
+  visibility: visible;
+}
+.chart-modal {
+  background: var(--bg-primary);
+  border-radius: 12px;
+  width: 90vw;
+  max-width: 1400px;
+  max-height: 85vh;
+  display: flex;
+  flex-direction: column;
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+}
+.chart-modal-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--border);
+}
+.chart-modal-header h3 {
+  margin: 0;
+  font-size: 16px;
+  color: var(--text-primary);
+}
+.chart-modal-close {
+  background: none;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  padding: 8px;
+  border-radius: 6px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.chart-modal-close:hover {
+  background: var(--bg-secondary);
+  color: var(--text-primary);
+}
+.chart-modal-body {
+  flex: 1;
+  padding: 20px;
+  min-height: 0;
+}
+.chart-modal-body .chart-container {
+  height: 100%;
+  min-height: 500px;
+}
+.chart-modal-body canvas {
+  width: 100% !important;
+  height: 100% !important;
+}
+
+/* Badges */
+.live-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 12px;
+  background: rgba(34, 197, 94, 0.2);
+  border-radius: 20px;
+  font-size: 12px;
+  color: var(--success);
+  font-weight: 500;
+}
+
+.live-badge::before {
+  content: '';
+  width: 8px;
+  height: 8px;
+  background: var(--success);
+  border-radius: 50%;
+  animation: pulse 1.5s infinite;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; transform: scale(1); }
+  50% { opacity: 0.5; transform: scale(0.9); }
+}
+
+.status-badge { padding: 4px 10px; border-radius: 4px; font-size: 12px; font-weight: 500; }
+.status-badge.good { background: rgba(34, 197, 94, 0.2); color: var(--success); }
+.status-badge.warn { background: rgba(234, 179, 8, 0.2); color: var(--warning); }
+.status-badge.bad { background: rgba(239, 68, 68, 0.2); color: var(--error); }
+
+/* Tables */
+table { width: 100%; border-collapse: collapse; }
+th, td { padding: 12px 16px; text-align: left; border-bottom: 1px solid var(--border); }
+th { color: var(--text-secondary); font-weight: 500; font-size: 11px; text-transform: uppercase; letter-spacing: 0.5px; }
+tr:hover { background: rgba(255, 255, 255, 0.02); }
+.clickable { color: var(--accent-cyan); cursor: pointer; }
+.clickable:hover { text-decoration: underline; }
+
+/* Buttons */
+.btn {
+  padding: 10px 20px;
+  border: none;
+  border-radius: 8px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s;
+  font-size: 14px;
+}
+
+.btn-primary {
+  background: linear-gradient(135deg, var(--accent-cyan), var(--accent-purple));
+  color: white;
+}
+
+.btn-primary:hover { opacity: 0.9; transform: translateY(-1px); }
+.btn-primary:disabled { opacity: 0.5; cursor: not-allowed; transform: none; }
+.btn-secondary { background: var(--bg-secondary); border: 1px solid var(--border); color: white; }
+.btn-danger { background: var(--error); color: white; }
+.btn-sm { padding: 6px 12px; font-size: 12px; }
+
+/* Empty state */
+.empty-state { text-align: center; padding: 60px 20px; color: var(--text-secondary); }
+.empty-state h3 { color: var(--text-primary); margin-bottom: 8px; font-size: 18px; }
+.empty-state code { background: var(--bg-secondary); padding: 2px 8px; border-radius: 4px; font-size: 13px; }
+
+/* Progress bar */
+.progress-bar { height: 8px; background: var(--bg-secondary); border-radius: 4px; overflow: hidden; }
+.progress-bar .fill { height: 100%; background: linear-gradient(90deg, var(--accent-cyan), var(--accent-purple)); transition: width 0.3s; }
+
+/* Test list */
+.test-list { max-height: 500px; overflow-y: auto; }
+
+.test-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--border);
+  transition: background 0.2s;
+}
+
+.test-item:hover { background: rgba(255, 255, 255, 0.02); }
+.test-item .test-info { flex: 1; }
+.test-item .test-name { font-weight: 500; color: var(--text-primary); }
+.test-item .test-path { font-size: 12px; color: var(--text-secondary); margin-top: 2px; }
+
+.test-type {
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 11px;
+  font-weight: 500;
+  text-transform: uppercase;
+}
+
+.test-type.api { background: rgba(0, 212, 255, 0.2); color: var(--accent-cyan); }
+.test-type.web { background: rgba(156, 64, 255, 0.2); color: var(--accent-purple); }
+
+/* Console output */
+.console-output {
+  background: #0d1117;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 16px;
+  font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+  font-size: 12px;
+  max-height: 400px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  word-break: break-all;
+}
+
+.console-output .line { padding: 2px 0; }
+.console-output .error { color: var(--error); }
+.console-output .success { color: var(--success); }
+
+/* Section tabs */
+.section-tabs {
+  display: flex;
+  gap: 4px;
+  margin-bottom: 16px;
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 8px;
+}
+
+.section-tab {
+  padding: 8px 16px;
+  background: none;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  font-size: 13px;
+  font-weight: 500;
+  border-bottom: 2px solid transparent;
+  margin-bottom: -9px;
+  transition: all 0.2s;
+}
+
+.section-tab:hover { color: var(--text-primary); }
+.section-tab.active { color: var(--accent-cyan); border-bottom-color: var(--accent-cyan); }
+
+/* Step stats table */
+.step-stats-table { font-size: 13px; }
+.step-stats-table th { font-size: 10px; padding: 8px 6px; white-space: nowrap; }
+.step-stats-table th:nth-child(n+4) { text-align: right; }
+.step-stats-table td { padding: 8px 6px; }
+.step-stats-table td:nth-child(n+4) { text-align: right; font-family: 'Monaco', 'Menlo', monospace; font-size: 12px; }
+
+.back-btn { margin-bottom: 20px; }

package/dist/dashboard/types.d.ts

@@ -0,0 +1,168 @@
+import { ChildProcess } from 'child_process';
+export interface DashboardOptions {
+    port: number;
+    resultsDir: string;
+    testsDir?: string;
+    workersFile?: string;
+}
+export interface TestResultSummary {
+    total_requests: number;
+    successful_requests: number;
+    failed_requests: number;
+    avg_response_time: number;
+    min_response_time: number;
+    max_response_time: number;
+    p50_response_time: number;
+    p75_response_time: number;
+    p90_response_time: number;
+    p95_response_time: number;
+    p99_response_time: number;
+    requests_per_second: number;
+    error_rate: number;
+    success_rate: number;
+}
+export interface ErrorDetail {
+    scenario: string;
+    action: string;
+    status?: number;
+    error: string;
+    request_url?: string;
+    count: number;
+}
+export interface NetworkCall {
+    id: string;
+    vuId: number;
+    url: string;
+    method: string;
+    status: number;
+    statusText?: string;
+    duration: number;
+    size: number;
+    type: string;
+    success: boolean;
+    error?: string;
+    timestamp: number;
+    requestHeaders?: Record<string, string>;
+    requestBody?: string;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+}
+export interface TestResult {
+    id: string;
+    name: string;
+    timestamp: string;
+    duration: number;
+    summary: TestResultSummary;
+    scenarios: any[];
+    step_statistics?: any[];
+    timeline_data?: any[];
+    vu_ramp_up?: any[];
+    response_time_distribution?: any[];
+    timeseries?: any[];
+    error_details?: ErrorDetail[];
+    network_calls?: any[];
+    infrastructure_metrics?: Record<string, InfrastructureMetrics[]>;
+    /** Individual test results (can come from file or InfluxDB) */
+    results?: any[];
+    raw?: any;
+}
+export interface TestFile {
+    name: string;
+    path: string;
+    relativePath: string;
+    type: 'api' | 'web' | 'mixed';
+    lastModified: string;
+}
+export interface LiveTestMetrics {
+    requests: number;
+    errors: number;
+    avgResponseTime: number;
+    currentVUs: number;
+    p50ResponseTime?: number;
+    p90ResponseTime?: number;
+    p95ResponseTime?: number;
+    p99ResponseTime?: number;
+    minResponseTime?: number;
+    maxResponseTime?: number;
+    requestsPerSecond?: number;
+    successRate?: number;
+}
+export interface StepStats {
+    stepName: string;
+    scenario: string;
+    requests: number;
+    errors: number;
+    avgResponseTime: number;
+    p50?: number;
+    p95?: number;
+    p99?: number;
+    successRate: number;
+}
+export interface ResponseTimePoint {
+    timestamp: number;
+    value: number;
+    success: boolean;
+    stepName?: string;
+}
+export interface TopError {
+    scenario: string;
+    action: string;
+    status?: number;
+    error: string;
+    url?: string;
+    count: number;
+}
+export interface HistoryPoint {
+    timestamp: number;
+    requests: number;
+    errors: number;
+    avgResponseTime: number;
+    p95ResponseTime: number;
+    p99ResponseTime: number;
+    vus: number;
+    rps: number;
+}
+export interface InfrastructureMetrics {
+    host: string;
+    timestamp: string;
+    interval_seconds: number;
+    metrics: {
+        cpu?: {
+            usage_percent: number;
+        };
+        memory?: {
+            used_mb: number;
+            total_mb: number;
+            usage_percent: number;
+        };
+        disk?: {
+            used_gb: number;
+            total_gb: number;
+            usage_percent: number;
+            path: string;
+        };
+        network?: {
+            bytes_in: number;
+            bytes_out: number;
+            interface: string;
+        };
+    };
+}
+export interface LiveTest {
+    id: string;
+    name: string;
+    startTime: Date;
+    status: 'running' | 'completed' | 'failed';
+    metrics: LiveTestMetrics;
+    stepStats: StepStats[];
+    responseTimes: ResponseTimePoint[];
+    topErrors: TopError[];
+    history: HistoryPoint[];
+    networkCalls?: NetworkCall[];
+    infrastructure?: Map<string, InfrastructureMetrics[]>;
+}
+export interface RunningProcess {
+    process: ChildProcess;
+    testId: string;
+    output: string[];
+}

package/dist/dashboard/types.js

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

package/dist/distributed/result-aggregator.js

@@ -109,8 +109,6 @@ class ResultAggregator {
                 totalVUs = new Set(this.results.map(r => r.vu_id)).size;
             }
         }
-        // Duration in seconds for report display
-        const totalDurationSeconds = duration / 1000;
         // Sort VU ramp-up events by start time for proper chart rendering
         const sortedVURampUp = [...this.vuRampUpEvents].sort((a, b) => a.start_time - b.start_time);
         return {
@@ -123,7 +121,7 @@ class ResultAggregator {
                 start_time: this.startTime,
                 end_time: this.endTime,
                 duration,
-                total_duration: totalDurationSeconds,
+                total_duration: duration, // Store in milliseconds for consistency
                 total_virtual_users: totalVUs,
                 peak_virtual_users: totalVUs,
                 successful_requests: successfulRequests,

package/dist/metrics/batch/batch-processor.d.ts

@@ -0,0 +1,27 @@
+import { TestResult } from '../types';
+export interface BatchConfig {
+    batchSize: number;
+    intervalMs?: number;
+    maxBufferSize: number;
+}
+export interface BatchFlushHandler {
+    (batch: TestResult[], batchNumber: number): Promise<void>;
+}
+export declare class BatchProcessor {
+    private config;
+    private buffer;
+    private batchTimer;
+    private batchCounter;
+    private onFlush;
+    constructor(config?: Partial<BatchConfig>);
+    setFlushHandler(handler: BatchFlushHandler): void;
+    start(): void;
+    stop(): void;
+    reset(): void;
+    private startTimer;
+    add(result: TestResult): void;
+    flush(): Promise<void>;
+    finalize(): Promise<void>;
+    getBatchCounter(): number;
+    getBufferSize(): number;
+}

package/dist/metrics/batch/batch-processor.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchProcessor = void 0;
+const logger_1 = require("../../utils/logger");
+class BatchProcessor {
+    constructor(config = {}) {
+        this.buffer = [];
+        this.batchTimer = null;
+        this.batchCounter = 0;
+        this.onFlush = null;
+        this.config = {
+            batchSize: config.batchSize || 10,
+            intervalMs: config.intervalMs,
+            maxBufferSize: config.maxBufferSize || 1000
+        };
+    }
+    setFlushHandler(handler) {
+        this.onFlush = handler;
+    }
+    start() {
+        if (this.config.intervalMs) {
+            this.startTimer();
+        }
+    }
+    stop() {
+        if (this.batchTimer) {
+            clearInterval(this.batchTimer);
+            this.batchTimer = null;
+        }
+    }
+    reset() {
+        this.stop();
+        this.buffer = [];
+        this.batchCounter = 0;
+    }
+    startTimer() {
+        this.batchTimer = setInterval(() => {
+            if (this.buffer.length > 0) {
+                this.flush();
+            }
+        }, this.config.intervalMs);
+    }
+    add(result) {
+        // Safety limit: force flush if buffer exceeds max size
+        if (this.buffer.length >= this.config.maxBufferSize) {
+            this.flush();
+        }
+        this.buffer.push(result);
+        // Check if we should flush based on batch size (if not using intervals)
+        if (!this.config.intervalMs) {
+            if (this.buffer.length >= this.config.batchSize) {
+                this.flush();
+            }
+        }
+    }
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        const batch = [...this.buffer];
+        this.buffer = [];
+        this.batchCounter++;
+        logger_1.logger.debug(`Flushing batch #${this.batchCounter} with ${batch.length} results`);
+        if (this.onFlush) {
+            try {
+                await this.onFlush(batch, this.batchCounter);
+            }
+            catch (error) {
+                logger_1.logger.error('Failed to flush metrics batch:', error);
+            }
+        }
+    }
+    async finalize() {
+        this.stop();
+        if (this.buffer.length > 0) {
+            await this.flush();
+        }
+    }
+    getBatchCounter() {
+        return this.batchCounter;
+    }
+    getBufferSize() {
+        return this.buffer.length;
+    }
+}
+exports.BatchProcessor = BatchProcessor;

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

@@ -0,0 +1 @@
+export { BatchProcessor, BatchConfig, BatchFlushHandler } from './batch-processor';

package/dist/metrics/batch/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchProcessor = void 0;
+var batch_processor_1 = require("./batch-processor");
+Object.defineProperty(exports, "BatchProcessor", { enumerable: true, get: function () { return batch_processor_1.BatchProcessor; } });