@testsmith/perfornium 0.6.3 → 0.6.5

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

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InfluxDBWriter = void 0;
+exports.getInfluxDBWriter = getInfluxDBWriter;
+exports.setInfluxDBWriter = setInfluxDBWriter;
+exports.initInfluxDBWriter = initInfluxDBWriter;
+const influxdb_client_1 = require("@influxdata/influxdb-client");
+const logger_1 = require("../../utils/logger");
+/**
+ * InfluxDB writer for test metrics (response times, network calls, etc.)
+ * This is optional - test results can still be stored as JSON files.
+ */
+class InfluxDBWriter {
+    constructor(config) {
+        this.client = null;
+        this.writeApi = null;
+        this.queryApi = null;
+        this.enabled = false;
+        this.currentTestId = '';
+        this.currentTestName = '';
+        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',
+            batchSize: config?.batchSize || 100,
+            flushInterval: config?.flushInterval || 1000
+        };
+    }
+    async connect() {
+        if (!this.config.token) {
+            logger_1.logger.debug('InfluxDB token not configured, test metrics will only be stored in files');
+            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', {
+                batchSize: this.config.batchSize,
+                flushInterval: this.config.flushInterval
+            });
+            this.queryApi = this.client.getQueryApi(this.config.org);
+            // Test connection
+            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(`InfluxDB connected for test metrics at ${this.config.url}`);
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to connect to InfluxDB for test metrics: ${error.message}`);
+            this.enabled = false;
+            return false;
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Start a new test run - sets the test ID and name for all subsequent writes
+     */
+    startTest(testId, testName) {
+        this.currentTestId = testId;
+        this.currentTestName = testName;
+        logger_1.logger.debug(`InfluxDB writer started for test: ${testName} (${testId})`);
+    }
+    /**
+     * Write a single test result to InfluxDB
+     */
+    async writeResult(result) {
+        if (!this.enabled || !this.writeApi)
+            return;
+        try {
+            const point = new influxdb_client_1.Point('test_result')
+                .tag('test_id', this.currentTestId)
+                .tag('test_name', this.currentTestName)
+                .tag('scenario', result.scenario || 'default')
+                .tag('action', result.action || result.step_name || 'unknown')
+                .tag('success', result.success ? 'true' : 'false')
+                .intField('vu_id', result.vu_id)
+                .intField('iteration', result.iteration || 0)
+                .floatField('duration', result.duration || 0)
+                .intField('status', result.status || 0)
+                .timestamp(new Date(result.timestamp));
+            if (result.response_size) {
+                point.intField('response_size', result.response_size);
+            }
+            if (result.connect_time !== undefined) {
+                point.floatField('connect_time', result.connect_time);
+            }
+            if (result.latency !== undefined) {
+                point.floatField('latency', result.latency);
+            }
+            if (result.error) {
+                point.stringField('error', result.error.substring(0, 255));
+            }
+            if (result.request_url) {
+                point.stringField('request_url', result.request_url.substring(0, 500));
+            }
+            if (result.request_method) {
+                point.tag('method', result.request_method);
+            }
+            this.writeApi.writePoint(point);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to write test result to InfluxDB: ${error.message}`);
+        }
+    }
+    /**
+     * Write a batch of test results to InfluxDB
+     */
+    async writeBatch(results) {
+        if (!this.enabled || !this.writeApi)
+            return;
+        for (const result of results) {
+            await this.writeResult(result);
+        }
+        try {
+            await this.writeApi.flush();
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to flush test results to InfluxDB: ${error.message}`);
+        }
+    }
+    /**
+     * Write a network call to InfluxDB
+     */
+    async writeNetworkCall(call) {
+        if (!this.enabled || !this.writeApi)
+            return;
+        try {
+            const point = new influxdb_client_1.Point('network_call')
+                .tag('test_id', this.currentTestId)
+                .tag('test_name', this.currentTestName)
+                .tag('method', call.request_method || 'GET')
+                .tag('success', call.success ? 'true' : 'false')
+                .tag('resource_type', call.resource_type || 'other')
+                .intField('vu_id', call.vu_id)
+                .floatField('duration', call.duration || 0)
+                .intField('status', call.response_status || 0)
+                .intField('response_size', call.response_size || 0)
+                .stringField('url', (call.request_url || '').substring(0, 500))
+                .timestamp(new Date(call.timestamp));
+            if (call.scenario) {
+                point.tag('scenario', call.scenario);
+            }
+            if (call.step_name) {
+                point.tag('step_name', call.step_name);
+            }
+            if (call.error) {
+                point.stringField('error', call.error.substring(0, 255));
+            }
+            this.writeApi.writePoint(point);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to write network call to InfluxDB: ${error.message}`);
+        }
+    }
+    /**
+     * Write test summary to InfluxDB
+     */
+    async writeSummary(summary) {
+        if (!this.enabled || !this.writeApi)
+            return;
+        try {
+            const point = new influxdb_client_1.Point('test_summary')
+                .tag('test_id', this.currentTestId)
+                .tag('test_name', this.currentTestName)
+                .intField('total_requests', summary.total_requests)
+                .intField('successful_requests', summary.successful_requests)
+                .intField('failed_requests', summary.failed_requests)
+                .floatField('success_rate', summary.success_rate)
+                .floatField('avg_response_time', summary.avg_response_time)
+                .floatField('min_response_time', summary.min_response_time)
+                .floatField('max_response_time', summary.max_response_time)
+                .floatField('p50', summary.percentiles[50] || 0)
+                .floatField('p90', summary.percentiles[90] || 0)
+                .floatField('p95', summary.percentiles[95] || 0)
+                .floatField('p99', summary.percentiles[99] || 0)
+                .floatField('requests_per_second', summary.requests_per_second)
+                .floatField('total_duration', summary.total_duration)
+                .timestamp(new Date());
+            this.writeApi.writePoint(point);
+            await this.writeApi.flush();
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to write test summary to InfluxDB: ${error.message}`);
+        }
+    }
+    /**
+     * Query test results from InfluxDB
+     */
+    async queryResults(options = {}) {
+        if (!this.enabled || !this.queryApi)
+            return [];
+        try {
+            const startTime = options.startTime || new Date(Date.now() - 24 * 60 * 60 * 1000);
+            const endTime = options.endTime || new Date();
+            // Validate time range
+            if (startTime.getTime() >= endTime.getTime()) {
+                logger_1.logger.debug('Invalid time range for test results query');
+                return [];
+            }
+            let query = `from(bucket: "${this.config.bucket}")
+        |> range(start: ${startTime.toISOString()}, stop: ${endTime.toISOString()})
+        |> filter(fn: (r) => r._measurement == "test_result")`;
+            if (options.testId) {
+                query += `\n        |> filter(fn: (r) => r.test_id == "${options.testId}")`;
+            }
+            if (options.testName) {
+                query += `\n        |> filter(fn: (r) => r.test_name == "${options.testName}")`;
+            }
+            if (options.scenario) {
+                query += `\n        |> filter(fn: (r) => r.scenario == "${options.scenario}")`;
+            }
+            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.rowsToResults(rows);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to query test results from InfluxDB: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Query network calls from InfluxDB
+     */
+    async queryNetworkCalls(options = {}) {
+        if (!this.enabled || !this.queryApi)
+            return [];
+        try {
+            const startTime = options.startTime || new Date(Date.now() - 24 * 60 * 60 * 1000);
+            const endTime = options.endTime || new Date();
+            // Validate time range
+            if (startTime.getTime() >= endTime.getTime()) {
+                logger_1.logger.debug('Invalid time range for network calls query');
+                return [];
+            }
+            let query = `from(bucket: "${this.config.bucket}")
+        |> range(start: ${startTime.toISOString()}, stop: ${endTime.toISOString()})
+        |> filter(fn: (r) => r._measurement == "network_call")`;
+            if (options.testId) {
+                query += `\n        |> filter(fn: (r) => r.test_id == "${options.testId}")`;
+            }
+            if (options.testName) {
+                query += `\n        |> filter(fn: (r) => r.test_name == "${options.testName}")`;
+            }
+            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.rowsToNetworkCalls(rows);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to query network calls from InfluxDB: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Get list of test runs
+     */
+    async getTestRuns(limit = 100) {
+        if (!this.enabled || !this.queryApi)
+            return [];
+        try {
+            const query = `from(bucket: "${this.config.bucket}")
+        |> range(start: -30d)
+        |> filter(fn: (r) => r._measurement == "test_summary")
+        |> keep(columns: ["test_id", "test_name", "_time"])
+        |> sort(columns: ["_time"], desc: true)
+        |> limit(n: ${limit})`;
+            const rows = await this.queryApi.collectRows(query);
+            return rows.map((row) => ({
+                testId: row.test_id,
+                testName: row.test_name,
+                timestamp: new Date(row._time)
+            }));
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to get test runs from InfluxDB: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Export test data for a specific test run
+     */
+    async exportTestData(testId, format = 'json') {
+        const results = await this.queryResults({ testId });
+        const networkCalls = await this.queryNetworkCalls({ testId });
+        const data = {
+            testId,
+            results,
+            networkCalls,
+            exportedAt: new Date().toISOString()
+        };
+        if (format === 'csv') {
+            return this.resultsToCSV(results);
+        }
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Finalize the current test - flush all pending writes
+     */
+    async finalize() {
+        if (this.writeApi) {
+            try {
+                await this.writeApi.flush();
+                logger_1.logger.debug('InfluxDB writer finalized for test: ' + this.currentTestName);
+            }
+            catch (error) {
+                logger_1.logger.error(`Failed to finalize InfluxDB writes: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Close the connection
+     */
+    async close() {
+        if (this.writeApi) {
+            await this.writeApi.close();
+        }
+    }
+    rowsToResults(rows) {
+        return rows.map(row => ({
+            id: `${row.test_id}-${row._time}`,
+            vu_id: row.vu_id || 0,
+            iteration: row.iteration || 0,
+            scenario: row.scenario || 'default',
+            action: row.action || 'unknown',
+            timestamp: new Date(row._time).getTime(),
+            duration: row.duration || 0,
+            success: row.success === 'true',
+            status: row.status || 0,
+            response_size: row.response_size,
+            connect_time: row.connect_time,
+            latency: row.latency,
+            error: row.error,
+            request_url: row.request_url,
+            request_method: row.method
+        }));
+    }
+    rowsToNetworkCalls(rows) {
+        return rows.map(row => ({
+            id: `${row.test_id}-${row._time}`,
+            vu_id: row.vu_id || 0,
+            timestamp: new Date(row._time).getTime(),
+            request_url: row.url || '',
+            request_method: row.method || 'GET',
+            response_status: row.status || 0,
+            response_size: row.response_size || 0,
+            start_time: new Date(row._time).getTime(),
+            duration: row.duration || 0,
+            resource_type: row.resource_type || 'other',
+            success: row.success === 'true',
+            error: row.error,
+            scenario: row.scenario,
+            step_name: row.step_name
+        }));
+    }
+    resultsToCSV(results) {
+        const headers = [
+            'timestamp', 'vu_id', 'iteration', 'scenario', 'action', 'success',
+            'duration', 'status', 'response_size', 'connect_time', 'latency',
+            'request_url', 'request_method', 'error'
+        ];
+        const rows = results.map(r => [
+            new Date(r.timestamp).toISOString(),
+            r.vu_id,
+            r.iteration || 0,
+            r.scenario,
+            r.action || '',
+            r.success,
+            r.duration || 0,
+            r.status || 0,
+            r.response_size || 0,
+            r.connect_time || 0,
+            r.latency || 0,
+            (r.request_url || '').replace(/,/g, ';'),
+            r.request_method || '',
+            (r.error || '').replace(/,/g, ';').replace(/\n/g, ' ')
+        ].join(','));
+        return [headers.join(','), ...rows].join('\n');
+    }
+}
+exports.InfluxDBWriter = InfluxDBWriter;
+// Singleton instance for global access
+let influxDBWriter = null;
+function getInfluxDBWriter() {
+    return influxDBWriter;
+}
+function setInfluxDBWriter(writer) {
+    influxDBWriter = writer;
+}
+async function initInfluxDBWriter(config) {
+    influxDBWriter = new InfluxDBWriter(config);
+    await influxDBWriter.connect();
+    return influxDBWriter;
+}

package/dist/metrics/realtime/dispatcher.d.ts

@@ -0,0 +1,18 @@
+import { TestResult } from '../types';
+export interface RealtimeEndpoint {
+    type: 'graphite' | 'webhook' | 'influxdb' | 'websocket';
+    url?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    token?: string;
+    headers?: Record<string, string>;
+}
+export declare class RealtimeDispatcher {
+    private endpoints;
+    private startTime;
+    setEndpoints(endpoints: RealtimeEndpoint[]): void;
+    setStartTime(time: number): void;
+    dispatch(batch: TestResult[], batchNumber: number): Promise<void>;
+    private sendToEndpoint;
+}

package/dist/metrics/realtime/dispatcher.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeDispatcher = void 0;
+const logger_1 = require("../../utils/logger");
+const graphite_1 = require("./endpoints/graphite");
+const webhook_1 = require("./endpoints/webhook");
+const influxdb_1 = require("./endpoints/influxdb");
+const websocket_1 = require("./endpoints/websocket");
+class RealtimeDispatcher {
+    constructor() {
+        this.endpoints = [];
+        this.startTime = 0;
+    }
+    setEndpoints(endpoints) {
+        this.endpoints = endpoints;
+    }
+    setStartTime(time) {
+        this.startTime = time;
+    }
+    async dispatch(batch, batchNumber) {
+        if (this.endpoints.length === 0)
+            return;
+        const promises = this.endpoints.map(endpoint => this.sendToEndpoint(batch, endpoint, batchNumber).catch(error => logger_1.logger.warn(`Failed to send to ${endpoint.type} endpoint:`, error)));
+        await Promise.allSettled(promises);
+    }
+    async sendToEndpoint(batch, endpoint, batchNumber) {
+        switch (endpoint.type) {
+            case 'graphite':
+                await (0, graphite_1.sendToGraphite)(batch, endpoint);
+                break;
+            case 'webhook':
+                await (0, webhook_1.sendToWebhook)(batch, endpoint, batchNumber, this.startTime);
+                break;
+            case 'influxdb':
+                await (0, influxdb_1.sendToInfluxDB)(batch, endpoint, batchNumber);
+                break;
+            case 'websocket':
+                await (0, websocket_1.sendToWebSocket)(batch, endpoint, batchNumber, this.startTime);
+                break;
+            default:
+                logger_1.logger.warn(`Unknown endpoint type: ${endpoint.type}`);
+        }
+    }
+}
+exports.RealtimeDispatcher = RealtimeDispatcher;

package/dist/metrics/realtime/endpoints/graphite.d.ts

@@ -0,0 +1,3 @@
+import { TestResult } from '../../types';
+import { RealtimeEndpoint } from '../dispatcher';
+export declare function sendToGraphite(batch: TestResult[], config: RealtimeEndpoint): Promise<void>;

package/dist/metrics/realtime/endpoints/graphite.js

@@ -0,0 +1,61 @@
+"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.sendToGraphite = sendToGraphite;
+const net = __importStar(require("net"));
+async function sendToGraphite(batch, config) {
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(config.port, config.host);
+        client.on('connect', () => {
+            const metrics = batch.map(result => {
+                const timestamp = Math.floor(result.timestamp / 1000);
+                const metricName = `loadtest.${result.scenario}.${result.step_name || result.action}`;
+                return [
+                    `${metricName}.duration ${result.duration} ${timestamp}`,
+                    `${metricName}.success ${result.success ? 1 : 0} ${timestamp}`,
+                    `${metricName}.count 1 ${timestamp}`
+                ].join('\n');
+            }).join('\n') + '\n';
+            client.write(metrics);
+            client.end();
+        });
+        client.on('close', () => resolve());
+        client.on('error', reject);
+        setTimeout(() => {
+            client.destroy();
+            reject(new Error('Graphite connection timeout'));
+        }, 5000);
+    });
+}

package/dist/metrics/realtime/endpoints/influxdb.d.ts

@@ -0,0 +1,3 @@
+import { TestResult } from '../../types';
+import { RealtimeEndpoint } from '../dispatcher';
+export declare function sendToInfluxDB(batch: TestResult[], config: RealtimeEndpoint, batchNumber: number): Promise<void>;

package/dist/metrics/realtime/endpoints/influxdb.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToInfluxDB = sendToInfluxDB;
+async function sendToInfluxDB(batch, config, batchNumber) {
+    const lines = batch.map(result => {
+        const tags = [
+            `scenario=${result.scenario}`,
+            `step=${result.step_name || result.action}`,
+            `vu_id=${result.vu_id}`,
+            `success=${result.success}`
+        ].join(',');
+        const fields = [
+            `duration=${result.duration}`,
+            `success=${result.success ? 'true' : 'false'}`,
+            `batch_number=${batchNumber}i`
+        ];
+        if (result.status) {
+            fields.push(`status=${result.status}i`);
+        }
+        const timestamp = result.timestamp * 1000000; // Convert to nanoseconds
+        return `loadtest,${tags} ${fields.join(',')} ${timestamp}`;
+    }).join('\n');
+    const response = await fetch(`${config.url}/write?db=${config.database}`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${config.token}`,
+            'Content-Type': 'text/plain'
+        },
+        body: lines
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`InfluxDB write failed: ${response.status} ${errorText}`);
+    }
+}

package/dist/metrics/realtime/endpoints/webhook.d.ts

@@ -0,0 +1,3 @@
+import { TestResult } from '../../types';
+import { RealtimeEndpoint } from '../dispatcher';
+export declare function sendToWebhook(batch: TestResult[], config: RealtimeEndpoint, batchNumber: number, startTime: number): Promise<void>;

package/dist/metrics/realtime/endpoints/webhook.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToWebhook = sendToWebhook;
+async function sendToWebhook(batch, config, batchNumber, startTime) {
+    const response = await fetch(config.url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...config.headers
+        },
+        body: JSON.stringify({
+            timestamp: new Date().toISOString(),
+            batch_number: batchNumber,
+            batch_size: batch.length,
+            test_start_time: new Date(startTime).toISOString(),
+            results: batch
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`Webhook failed: ${response.status} ${response.statusText}`);
+    }
+}

package/dist/metrics/realtime/endpoints/websocket.d.ts

@@ -0,0 +1,3 @@
+import { TestResult } from '../../types';
+import { RealtimeEndpoint } from '../dispatcher';
+export declare function sendToWebSocket(batch: TestResult[], config: RealtimeEndpoint, batchNumber: number, startTime: number): Promise<void>;

package/dist/metrics/realtime/endpoints/websocket.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToWebSocket = sendToWebSocket;
+const ws_1 = require("ws");
+async function sendToWebSocket(batch, config, batchNumber, startTime) {
+    return new Promise((resolve, reject) => {
+        const ws = new ws_1.WebSocket(config.url);
+        ws.on('open', () => {
+            ws.send(JSON.stringify({
+                type: 'metrics_batch',
+                timestamp: new Date().toISOString(),
+                batch_number: batchNumber,
+                test_start_time: new Date(startTime).toISOString(),
+                data: batch
+            }));
+            ws.close();
+            resolve();
+        });
+        ws.on('error', reject);
+        setTimeout(() => {
+            ws.close();
+            reject(new Error('WebSocket connection timeout'));
+        }, 5000);
+    });
+}

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

@@ -0,0 +1,5 @@
+export { RealtimeDispatcher, RealtimeEndpoint } from './dispatcher';
+export { sendToGraphite } from './endpoints/graphite';
+export { sendToWebhook } from './endpoints/webhook';
+export { sendToInfluxDB } from './endpoints/influxdb';
+export { sendToWebSocket } from './endpoints/websocket';

package/dist/metrics/realtime/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToWebSocket = exports.sendToInfluxDB = exports.sendToWebhook = exports.sendToGraphite = exports.RealtimeDispatcher = void 0;
+var dispatcher_1 = require("./dispatcher");
+Object.defineProperty(exports, "RealtimeDispatcher", { enumerable: true, get: function () { return dispatcher_1.RealtimeDispatcher; } });
+var graphite_1 = require("./endpoints/graphite");
+Object.defineProperty(exports, "sendToGraphite", { enumerable: true, get: function () { return graphite_1.sendToGraphite; } });
+var webhook_1 = require("./endpoints/webhook");
+Object.defineProperty(exports, "sendToWebhook", { enumerable: true, get: function () { return webhook_1.sendToWebhook; } });
+var influxdb_1 = require("./endpoints/influxdb");
+Object.defineProperty(exports, "sendToInfluxDB", { enumerable: true, get: function () { return influxdb_1.sendToInfluxDB; } });
+var websocket_1 = require("./endpoints/websocket");
+Object.defineProperty(exports, "sendToWebSocket", { enumerable: true, get: function () { return websocket_1.sendToWebSocket; } });

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

@@ -0,0 +1,3 @@
+export { SummaryGenerator, SummaryGeneratorDependencies } from './summary-generator';
+export { StepStatisticsCalculator } from './step-statistics';
+export { TimelineCalculator } from './timeline-calculator';

package/dist/metrics/reporting/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineCalculator = exports.StepStatisticsCalculator = exports.SummaryGenerator = void 0;
+var summary_generator_1 = require("./summary-generator");
+Object.defineProperty(exports, "SummaryGenerator", { enumerable: true, get: function () { return summary_generator_1.SummaryGenerator; } });
+var step_statistics_1 = require("./step-statistics");
+Object.defineProperty(exports, "StepStatisticsCalculator", { enumerable: true, get: function () { return step_statistics_1.StepStatisticsCalculator; } });
+var timeline_calculator_1 = require("./timeline-calculator");
+Object.defineProperty(exports, "TimelineCalculator", { enumerable: true, get: function () { return timeline_calculator_1.TimelineCalculator; } });