@testsmith/perfornium 0.6.4 → 0.6.5

package/dist/dashboard/services/file-scanner.d.ts

@@ -0,0 +1,7 @@
+import { TestFile } from '../types';
+export declare class FileScanner {
+    private testsDir;
+    constructor(testsDir: string);
+    scanTestFiles(): Promise<TestFile[]>;
+    private scanDirForTests;
+}

package/dist/dashboard/services/file-scanner.js

@@ -0,0 +1,114 @@
+"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.FileScanner = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class FileScanner {
+    constructor(testsDir) {
+        this.testsDir = testsDir;
+    }
+    async scanTestFiles() {
+        const tests = [];
+        // Only scan dedicated test directories
+        const searchDirs = [
+            path.join(this.testsDir, 'tests'),
+            path.join(this.testsDir, 'tmp/tests')
+        ];
+        for (const dir of searchDirs) {
+            try {
+                await this.scanDirForTests(dir, tests, this.testsDir);
+            }
+            catch (e) {
+                // Directory might not exist
+            }
+        }
+        return tests.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    }
+    async scanDirForTests(dir, tests, baseDir) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules' &&
+                    entry.name !== 'data' && entry.name !== 'config' && entry.name !== 'environments') {
+                    await this.scanDirForTests(fullPath, tests, baseDir);
+                }
+                else if (entry.isFile() && (entry.name.endsWith('.yml') || entry.name.endsWith('.yaml') || entry.name.endsWith('.json'))) {
+                    // Skip obvious non-test files
+                    if (entry.name.includes('package') || entry.name.includes('tsconfig') ||
+                        entry.name.includes('env') || entry.name === 'CNAME' ||
+                        entry.name.includes('credentials') || entry.name.includes('config'))
+                        continue;
+                    try {
+                        const content = await fs.readFile(fullPath, 'utf-8');
+                        // Only include files that look like actual test configs (have scenarios or steps)
+                        if (!content.includes('scenarios:') && !content.includes('steps:') &&
+                            !content.includes('"scenarios"') && !content.includes('"steps"')) {
+                            continue;
+                        }
+                        const stat = await fs.stat(fullPath);
+                        const relativePath = path.relative(baseDir, fullPath);
+                        // Detect test type from content or path (use forward slashes for cross-platform matching)
+                        const normalizedPath = fullPath.replace(/\\/g, '/');
+                        let testType = 'api';
+                        if (content.includes('protocol: web') || content.includes('playwright') || normalizedPath.includes('/web/')) {
+                            testType = 'web';
+                        }
+                        else if (content.includes('protocol: http') || content.includes('protocol: https') || normalizedPath.includes('/api/')) {
+                            testType = 'api';
+                        }
+                        // Normalize paths to forward slashes for cross-platform compatibility
+                        const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+                        tests.push({
+                            name: entry.name.replace(/\.(yml|yaml|json)$/, ''),
+                            path: fullPath, // Keep native path for filesystem operations
+                            relativePath: normalizedRelativePath, // Use forward slashes for display/URLs
+                            type: testType,
+                            lastModified: stat.mtime.toISOString()
+                        });
+                    }
+                    catch (e) {
+                        // Skip unreadable files
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Skip inaccessible directories
+        }
+    }
+}
+exports.FileScanner = FileScanner;

package/dist/dashboard/services/index.d.ts

@@ -0,0 +1,5 @@
+export { FileScanner } from './file-scanner';
+export { ResultsManager } from './results-manager';
+export { MetricsParser, MetricsParserOptions } from './metrics-parser';
+export { TestExecutor, TestRunOptions, TestExecutorCallbacks, TestExecutorOptions } from './test-executor';
+export { WorkersManager, WorkersInfo } from './workers-manager';

package/dist/dashboard/services/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkersManager = exports.TestExecutor = exports.MetricsParser = exports.ResultsManager = exports.FileScanner = void 0;
+var file_scanner_1 = require("./file-scanner");
+Object.defineProperty(exports, "FileScanner", { enumerable: true, get: function () { return file_scanner_1.FileScanner; } });
+var results_manager_1 = require("./results-manager");
+Object.defineProperty(exports, "ResultsManager", { enumerable: true, get: function () { return results_manager_1.ResultsManager; } });
+var metrics_parser_1 = require("./metrics-parser");
+Object.defineProperty(exports, "MetricsParser", { enumerable: true, get: function () { return metrics_parser_1.MetricsParser; } });
+var test_executor_1 = require("./test-executor");
+Object.defineProperty(exports, "TestExecutor", { enumerable: true, get: function () { return test_executor_1.TestExecutor; } });
+var workers_manager_1 = require("./workers-manager");
+Object.defineProperty(exports, "WorkersManager", { enumerable: true, get: function () { return workers_manager_1.WorkersManager; } });

package/dist/dashboard/services/influxdb-service.d.ts

@@ -0,0 +1,41 @@
+import { InfrastructureMetrics } from '../types';
+export interface InfluxDBConfig {
+    url: string;
+    token: string;
+    org: string;
+    bucket: string;
+}
+export interface InfraQueryOptions {
+    host?: string;
+    startTime?: Date;
+    endTime?: Date;
+    testId?: string;
+    limit?: number;
+}
+export declare class InfluxDBService {
+    private client;
+    private writeApi;
+    private queryApi;
+    private config;
+    private enabled;
+    private fallbackBuffer;
+    private readonly MAX_BUFFER_SIZE;
+    constructor(config?: Partial<InfluxDBConfig>);
+    connect(): Promise<boolean>;
+    isEnabled(): boolean;
+    writeMetrics(data: InfrastructureMetrics): Promise<void>;
+    queryMetrics(options?: InfraQueryOptions): Promise<InfrastructureMetrics[]>;
+    queryMetricsByTestRun(testId: string, startTime: Date, endTime: Date): Promise<Record<string, InfrastructureMetrics[]>>;
+    getHosts(): Promise<string[]>;
+    getLatestMetrics(): Promise<Record<string, InfrastructureMetrics | null>>;
+    exportMetrics(options: InfraQueryOptions, format?: 'json' | 'csv'): Promise<string>;
+    importMetrics(data: string, format?: 'json' | 'csv'): Promise<number>;
+    deleteMetrics(options: InfraQueryOptions): Promise<void>;
+    getSnapshot(): Record<string, InfrastructureMetrics[]>;
+    private addToFallbackBuffer;
+    private queryFallbackBuffer;
+    private rowsToMetrics;
+    private metricsToCSV;
+    private csvToMetrics;
+    close(): Promise<void>;
+}

package/dist/dashboard/services/influxdb-service.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfluxDBService = void 0;
+const influxdb_client_1 = require("@influxdata/influxdb-client");
+const logger_1 = require("../../utils/logger");
+class InfluxDBService {
+    constructor(config) {
+        this.client = null;
+        this.writeApi = null;
+        this.queryApi = null;
+        this.enabled = false;
+        this.fallbackBuffer = new Map();
+        this.MAX_BUFFER_SIZE = 120;
+        this.config = {
+            url: config?.url || process.env.INFLUXDB_URL || 'http://localhost:8086',
+            token: config?.token || process.env.INFLUXDB_TOKEN || '',
+            org: config?.org || process.env.INFLUXDB_ORG || 'perfornium',
+            bucket: config?.bucket || process.env.INFLUXDB_BUCKET || 'metrics'
+        };
+    }
+    async connect() {
+        if (!this.config.token) {
+            logger_1.logger.info('InfluxDB token not configured, using in-memory storage');
+            return false;
+        }
+        try {
+            this.client = new influxdb_client_1.InfluxDB({
+                url: this.config.url,
+                token: this.config.token
+            });
+            this.writeApi = this.client.getWriteApi(this.config.org, this.config.bucket, 'ms');
+            this.queryApi = this.client.getQueryApi(this.config.org);
+            // Test connection with a simple query
+            const query = `from(bucket: "${this.config.bucket}") |> range(start: -1s) |> limit(n: 1)`;
+            await this.queryApi.collectRows(query);
+            this.enabled = true;
+            logger_1.logger.info(`Connected to InfluxDB at ${this.config.url}`);
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to connect to InfluxDB: ${error.message}. Using in-memory storage.`);
+            this.enabled = false;
+            return false;
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    async writeMetrics(data) {
+        // Always store in fallback buffer for real-time display
+        this.addToFallbackBuffer(data);
+        if (!this.enabled || !this.writeApi) {
+            return;
+        }
+        try {
+            const point = new influxdb_client_1.Point('infrastructure_metrics')
+                .tag('host', data.host)
+                .floatField('cpu_usage', data.metrics?.cpu?.usage_percent || 0)
+                .floatField('memory_usage', data.metrics?.memory?.usage_percent || 0)
+                .floatField('memory_used_mb', data.metrics?.memory?.used_mb || 0)
+                .floatField('memory_total_mb', data.metrics?.memory?.total_mb || 0)
+                .floatField('disk_usage', data.metrics?.disk?.usage_percent || 0)
+                .floatField('disk_used_gb', data.metrics?.disk?.used_gb || 0)
+                .floatField('disk_total_gb', data.metrics?.disk?.total_gb || 0)
+                .stringField('disk_path', data.metrics?.disk?.path || '/')
+                .floatField('network_bytes_in', data.metrics?.network?.bytes_in || 0)
+                .floatField('network_bytes_out', data.metrics?.network?.bytes_out || 0)
+                .stringField('network_interface', data.metrics?.network?.interface || 'eth0')
+                .intField('interval_seconds', data.interval_seconds || 5)
+                .timestamp(new Date(data.timestamp));
+            this.writeApi.writePoint(point);
+            await this.writeApi.flush();
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to write to InfluxDB: ${error.message}`);
+        }
+    }
+    async queryMetrics(options = {}) {
+        if (!this.enabled || !this.queryApi) {
+            return this.queryFallbackBuffer(options);
+        }
+        try {
+            const startTime = options.startTime || new Date(Date.now() - 10 * 60 * 1000); // Default 10 minutes
+            const endTime = options.endTime || new Date();
+            // Validate time range - start must be before end
+            if (startTime.getTime() >= endTime.getTime()) {
+                logger_1.logger.debug('Invalid time range for InfluxDB query, using fallback buffer');
+                return this.queryFallbackBuffer(options);
+            }
+            let query = `from(bucket: "${this.config.bucket}")
+        |> range(start: ${startTime.toISOString()}, stop: ${endTime.toISOString()})
+        |> filter(fn: (r) => r._measurement == "infrastructure_metrics")`;
+            if (options.host) {
+                query += `\n        |> filter(fn: (r) => r.host == "${options.host}")`;
+            }
+            query += `\n        |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")`;
+            if (options.limit) {
+                query += `\n        |> limit(n: ${options.limit})`;
+            }
+            const rows = await this.queryApi.collectRows(query);
+            return this.rowsToMetrics(rows);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to query InfluxDB: ${error.message}`);
+            return this.queryFallbackBuffer(options);
+        }
+    }
+    async queryMetricsByTestRun(testId, startTime, endTime) {
+        const metrics = await this.queryMetrics({ startTime, endTime });
+        // Group by host
+        const grouped = {};
+        for (const metric of metrics) {
+            if (!grouped[metric.host]) {
+                grouped[metric.host] = [];
+            }
+            grouped[metric.host].push(metric);
+        }
+        return grouped;
+    }
+    async getHosts() {
+        if (!this.enabled || !this.queryApi) {
+            return Array.from(this.fallbackBuffer.keys());
+        }
+        try {
+            const query = `from(bucket: "${this.config.bucket}")
+        |> range(start: -24h)
+        |> filter(fn: (r) => r._measurement == "infrastructure_metrics")
+        |> keep(columns: ["host"])
+        |> distinct(column: "host")`;
+            const rows = await this.queryApi.collectRows(query);
+            return rows.map((row) => row.host).filter(Boolean);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to get hosts from InfluxDB: ${error.message}`);
+            return Array.from(this.fallbackBuffer.keys());
+        }
+    }
+    async getLatestMetrics() {
+        const hosts = await this.getHosts();
+        const result = {};
+        for (const host of hosts) {
+            const metrics = await this.queryMetrics({ host, limit: 1 });
+            result[host] = metrics.length > 0 ? metrics[metrics.length - 1] : null;
+        }
+        // Include fallback buffer hosts
+        for (const [host, buffer] of this.fallbackBuffer) {
+            if (!result[host] && buffer.length > 0) {
+                result[host] = buffer[buffer.length - 1];
+            }
+        }
+        return result;
+    }
+    async exportMetrics(options, format = 'json') {
+        const metrics = await this.queryMetrics(options);
+        if (format === 'csv') {
+            return this.metricsToCSV(metrics);
+        }
+        return JSON.stringify(metrics, null, 2);
+    }
+    async importMetrics(data, format = 'json') {
+        let metrics;
+        if (format === 'csv') {
+            metrics = this.csvToMetrics(data);
+        }
+        else {
+            metrics = JSON.parse(data);
+        }
+        let count = 0;
+        for (const metric of metrics) {
+            await this.writeMetrics(metric);
+            count++;
+        }
+        return count;
+    }
+    async deleteMetrics(options) {
+        if (!this.enabled || !this.client) {
+            // Clear fallback buffer for host if specified
+            if (options.host) {
+                this.fallbackBuffer.delete(options.host);
+            }
+            else {
+                this.fallbackBuffer.clear();
+            }
+            return;
+        }
+        // Note: InfluxDB 2.x delete requires Delete API
+        // For simplicity, we'll just let data expire via retention policy
+        logger_1.logger.warn('Delete operation not fully implemented for InfluxDB. Consider using retention policies.');
+    }
+    getSnapshot() {
+        const snapshot = {};
+        for (const [host, metrics] of this.fallbackBuffer) {
+            snapshot[host] = [...metrics];
+        }
+        return snapshot;
+    }
+    addToFallbackBuffer(data) {
+        if (!this.fallbackBuffer.has(data.host)) {
+            this.fallbackBuffer.set(data.host, []);
+        }
+        const buffer = this.fallbackBuffer.get(data.host);
+        buffer.push(data);
+        if (buffer.length > this.MAX_BUFFER_SIZE) {
+            buffer.shift();
+        }
+    }
+    queryFallbackBuffer(options) {
+        let result = [];
+        if (options.host) {
+            result = this.fallbackBuffer.get(options.host) || [];
+        }
+        else {
+            for (const buffer of this.fallbackBuffer.values()) {
+                result = result.concat(buffer);
+            }
+        }
+        // Filter by time range
+        if (options.startTime || options.endTime) {
+            result = result.filter(m => {
+                const ts = new Date(m.timestamp).getTime();
+                if (options.startTime && ts < options.startTime.getTime())
+                    return false;
+                if (options.endTime && ts > options.endTime.getTime())
+                    return false;
+                return true;
+            });
+        }
+        // Sort by timestamp
+        result.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        if (options.limit) {
+            result = result.slice(-options.limit);
+        }
+        return result;
+    }
+    rowsToMetrics(rows) {
+        return rows.map(row => ({
+            host: row.host,
+            timestamp: row._time,
+            interval_seconds: row.interval_seconds || 5,
+            metrics: {
+                cpu: { usage_percent: row.cpu_usage || 0 },
+                memory: {
+                    usage_percent: row.memory_usage || 0,
+                    used_mb: row.memory_used_mb || 0,
+                    total_mb: row.memory_total_mb || 0
+                },
+                disk: {
+                    usage_percent: row.disk_usage || 0,
+                    used_gb: row.disk_used_gb || 0,
+                    total_gb: row.disk_total_gb || 0,
+                    path: row.disk_path || '/'
+                },
+                network: {
+                    bytes_in: row.network_bytes_in || 0,
+                    bytes_out: row.network_bytes_out || 0,
+                    interface: row.network_interface || 'eth0'
+                }
+            }
+        }));
+    }
+    metricsToCSV(metrics) {
+        const headers = [
+            'timestamp', 'host', 'interval_seconds',
+            'cpu_usage', 'memory_usage', 'memory_used_mb', 'memory_total_mb',
+            'disk_usage', 'disk_used_gb', 'disk_total_gb', 'disk_path',
+            'network_bytes_in', 'network_bytes_out', 'network_interface'
+        ];
+        const rows = metrics.map(m => [
+            m.timestamp,
+            m.host,
+            m.interval_seconds || 5,
+            m.metrics?.cpu?.usage_percent || 0,
+            m.metrics?.memory?.usage_percent || 0,
+            m.metrics?.memory?.used_mb || 0,
+            m.metrics?.memory?.total_mb || 0,
+            m.metrics?.disk?.usage_percent || 0,
+            m.metrics?.disk?.used_gb || 0,
+            m.metrics?.disk?.total_gb || 0,
+            m.metrics?.disk?.path || '/',
+            m.metrics?.network?.bytes_in || 0,
+            m.metrics?.network?.bytes_out || 0,
+            m.metrics?.network?.interface || 'eth0'
+        ].join(','));
+        return [headers.join(','), ...rows].join('\n');
+    }
+    csvToMetrics(csv) {
+        const lines = csv.trim().split('\n');
+        if (lines.length < 2)
+            return [];
+        const headers = lines[0].split(',');
+        const metrics = [];
+        for (let i = 1; i < lines.length; i++) {
+            const values = lines[i].split(',');
+            const row = {};
+            headers.forEach((h, idx) => row[h] = values[idx]);
+            metrics.push({
+                timestamp: row.timestamp,
+                host: row.host,
+                interval_seconds: parseInt(row.interval_seconds) || 5,
+                metrics: {
+                    cpu: { usage_percent: parseFloat(row.cpu_usage) || 0 },
+                    memory: {
+                        usage_percent: parseFloat(row.memory_usage) || 0,
+                        used_mb: parseFloat(row.memory_used_mb) || 0,
+                        total_mb: parseFloat(row.memory_total_mb) || 0
+                    },
+                    disk: {
+                        usage_percent: parseFloat(row.disk_usage) || 0,
+                        used_gb: parseFloat(row.disk_used_gb) || 0,
+                        total_gb: parseFloat(row.disk_total_gb) || 0,
+                        path: row.disk_path || '/'
+                    },
+                    network: {
+                        bytes_in: parseFloat(row.network_bytes_in) || 0,
+                        bytes_out: parseFloat(row.network_bytes_out) || 0,
+                        interface: row.network_interface || 'eth0'
+                    }
+                }
+            });
+        }
+        return metrics;
+    }
+    async close() {
+        if (this.writeApi) {
+            await this.writeApi.close();
+        }
+    }
+}
+exports.InfluxDBService = InfluxDBService;

package/dist/dashboard/services/metrics-parser.d.ts

@@ -0,0 +1,12 @@
+import { LiveTest } from '../types';
+export interface MetricsParserOptions {
+    /** When InfluxDB is enabled, don't limit response times (data is persisted) */
+    influxEnabled?: boolean;
+}
+export declare class MetricsParser {
+    private influxEnabled;
+    constructor(options?: MetricsParserOptions);
+    parseOutputForMetrics(line: string, test: LiveTest): boolean;
+    private addHistoryEntry;
+    parseNetworkData(line: string): any | null;
+}