apm-optima 0.0.1

package/dist/core/utility/statistics.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = hash;
+exports.rate = rate;
+exports.mean = mean;
+exports.percentile = percentile;
+exports.percentileHistogram = percentileHistogram;
+exports.median = median;
+exports.calculateSampleSizeProportion = calculateSampleSizeProportion;
+exports.pearsonCorrelation = pearsonCorrelation;
+exports.spearmanCorrelation = spearmanCorrelation;
+exports.determinationAndAlienation = determinationAndAlienation;
+exports.standardDeviation = standardDeviation;
+exports.standardDeviationHistogram = standardDeviationHistogram;
+exports.zScore = zScore;
+exports.zScoreHistogram = zScoreHistogram;
+exports.isDataAnomaly = isDataAnomaly;
+exports.isDataAnomalyHistogram = isDataAnomalyHistogram;
+/**
+ * Generates a hash code for a given value. This function converts the value to a JSON string and computes a hash code based on its characters.
+ * @param value The value to be hashed. It can be of any type that can be serialized to JSON.
+ * @returns The hash code for the given value.
+ */
+function hash(value) {
+    const str = JSON.stringify(value);
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
+/**
+ * Calculates the rate as a percentage of accounted over total.
+ * @param accounted The number of items accounted for.
+ * @param total The total number of items.
+ * @returns The rate as a percentage.
+ */
+function rate(accounted, total) {
+    if (total === 0)
+        return 0;
+    return (accounted / total) * 100;
+}
+/**
+ * Calculates the mean (average) of a dataset.
+ * @param data - An array of numbers representing the dataset.
+ * @returns The mean of the dataset.
+ */
+function mean(data) {
+    if (data.length === 0)
+        return 0;
+    const sum = data.reduce((acc, val) => acc + val, 0);
+    return sum / data.length;
+}
+/**
+ * Calculates the specified percentile of a dataset. (e.g., p95, p99)
+ * @param data - An array of numbers representing the dataset.
+ * @param percentile - The desired percentile (between 0 and 1, e.g., 0.95 for p95).
+ * @returns The value at the specified percentile of the dataset.
+ */
+function percentile(data, percentile) {
+    if (data.length === 0)
+        return 0;
+    if (percentile >= 1)
+        return Math.max(...data);
+    else if (percentile <= 0)
+        return Math.min(...data);
+    const sorted = [...data].sort((a, b) => a - b);
+    const index = percentile * (sorted.length - 1);
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    if (lower === upper) {
+        return sorted[lower];
+    }
+    return sorted[lower] + (sorted[upper] - sorted[lower]) * (index - lower);
+}
+/**
+ * Calculates the specified percentile of a histogram represented by counters and limits.
+ * This function is useful for determining latency percentiles from histogram data.
+ * @param counters An array of counts representing the number of occurrences in each histogram bucket.
+ * @param totalCount The total number of occurrences across all histogram buckets.
+ * @param percentile The desired percentile (between 0 and 1, e.g., 0.95 for p95).
+ * @param limits An array of upper limits for each histogram bucket, corresponding to the counters.
+ * @returns The value at the specified percentile of the histogram.
+ */
+function percentileHistogram(counters, totalCount, percentile, limits) {
+    if (totalCount === 0)
+        return 0;
+    if (percentile >= 1) {
+        const last = limits[limits.length - 1];
+        return Number.isFinite(last) ? last : 0;
+    }
+    else if (percentile <= 0) {
+        const first = limits[0];
+        return Number.isFinite(first) ? first : 0;
+    }
+    const target = totalCount * percentile;
+    let cumulative = 0;
+    for (let i = 0; i < counters.length; i++) {
+        const previous = cumulative;
+        cumulative += counters[i];
+        if (cumulative >= target) {
+            const lower = i === 0 ? 0 : limits[i - 1];
+            const upper = Number.isFinite(limits[i]) ? limits[i] : lower;
+            if (upper === lower)
+                return upper;
+            const bucketCount = cumulative - previous;
+            const bucketPosition = bucketCount === 0
+                ? 0
+                : (target - previous) / bucketCount;
+            return lower + (upper - lower) * bucketPosition;
+        }
+    }
+    return limits[limits.length - 1];
+}
+/**
+ * Calculates the median (p50) of a dataset.
+ * @param data - An array of numbers representing the dataset.
+ * @returns The median of the dataset.
+ */
+function median(data) {
+    if (data.length === 0)
+        return 0;
+    const sorted = [...data].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[mid - 1] + sorted[mid]) / 2;
+    }
+    else {
+        return sorted[mid];
+    }
+}
+/**
+ * Calculates the inverse of the standard normal cumulative distribution function (CDF).
+ * @param p The probability value (between 0 and 1) for which to calculate the inverse CDF.
+ * @returns The z-score corresponding to the given probability value.
+ */
+function normsinv(p) {
+    if (p <= 0 || p >= 1)
+        return 0;
+    const t = Math.sqrt(-2.0 * Math.log(p < 0.5 ? p : 1.0 - p));
+    const c0 = 2.515517, c1 = 0.802853, c2 = 0.010328;
+    const d1 = 1.432788, d2 = 0.189269, d3 = 0.001308;
+    const index = t - ((c2 * t + c1) * t + c0) / (((d3 * t + d2) * t + d1) * t + 1.0);
+    return p < 0.5 ? -index : index;
+}
+/**
+ * Calculates the required sample size for estimating a population proportion with a specified margin of error and confidence level.
+ * The formula used is based on the normal approximation to the binomial distribution.
+ * @param marginOfError The desired margin of error (e.g., 0.05 for ±5%).
+ * @param confidenceLevel The desired confidence level (default is 0.95 for 95% confidence).
+ * @returns The required sample size to achieve the specified margin of error and confidence level.
+ */
+function calculateSampleSizeProportion(marginOfError, confidenceLevel = 0.95) {
+    const alpha = 1 - confidenceLevel;
+    const z = normsinv(1 - (alpha / 2));
+    const p = 0.5;
+    const n = (Math.pow(z, 2) * p * (1 - p)) / Math.pow(marginOfError, 2);
+    return Math.ceil(n);
+}
+/**
+ * Calculates the Pearson correlation coefficient (r) between two datasets.
+ * The correlation coefficient measures the strength and direction of the linear relationship between two variables.
+ * The value of r ranges from -1 to 1, where:
+ * - r = 1 indicates a perfect positive correlation,
+ * - r = -1 indicates a perfect negative correlation,
+ * - r = 0 indicates no correlation.
+ *
+ * The function also provides an interpretation of the correlation strength and assigns a color class for visualization purposes.
+ * @param x The first dataset (X values) as an array of numbers.
+ * @param y The second dataset (Y values) as an array of numbers.
+ * @returns The Pearson correlation coefficient (r).
+ */
+function pearsonCorrelation(x, y) {
+    if (x.length !== y.length || x.length === 0)
+        return 0;
+    const n = x.length;
+    const meanX = x.reduce((a, b) => a + b, 0) / n;
+    const meanY = y.reduce((a, b) => a + b, 0) / n;
+    let numerator = 0;
+    let denominatorX = 0;
+    let denominatorY = 0;
+    for (let i = 0; i < n; i++) {
+        const diffX = x[i] - meanX;
+        const diffY = y[i] - meanY;
+        numerator += diffX * diffY;
+        denominatorX += diffX * diffX;
+        denominatorY += diffY * diffY;
+    }
+    const denominator = Math.sqrt(denominatorX * denominatorY);
+    return denominator === 0 ? 0 : numerator / denominator;
+}
+/**
+ * Calculates the ranks of the elements in an array. The rank of an element is its position in the sorted order of the array, with ties receiving the average rank.
+ * For example, in the array [3, 1, 2], the ranks would be [3, 1, 2] because 1 is the smallest (rank 1), 2 is the second smallest (rank 2), and 3 is the largest (rank 3).
+ * In the case of ties, such as in the array [3, 1, 2, 2], the ranks would be [4, 1, 2.5, 2.5] because both occurrences of 2 share the average rank of (2 + 3) / 2 = 2.5.
+ * @param arr An array of numbers for which to calculate the ranks.
+ * @returns An array of ranks corresponding to the input array, where each rank indicates the position of the element in the sorted order.
+ */
+function getRanks(arr) {
+    const sorted = [...arr].map((val, ind) => ({ val, ind })).sort((a, b) => a.val - b.val);
+    const ranks = new Array(arr.length);
+    let i = 0;
+    while (i < sorted.length) {
+        let j = i;
+        while (j < sorted.length && sorted[j].val === sorted[i].val) {
+            j++;
+        }
+        const rank = (i + 1 + j) / 2;
+        for (let k = i; k < j; k++) {
+            ranks[sorted[k].ind] = rank;
+        }
+        i = j;
+    }
+    return ranks;
+}
+/**
+ * Calculates the Spearman rank correlation coefficient (ρ) between two datasets.
+ * @param x An array of numbers representing the first dataset.
+ * @param y An array of numbers representing the second dataset.
+ * @returns The Spearman rank correlation coefficient (ρ).
+ */
+function spearmanCorrelation(x, y) {
+    if (x.length !== y.length || x.length === 0)
+        return 0;
+    const n = x.length;
+    const ranksX = getRanks(x);
+    const ranksY = getRanks(y);
+    const meanRX = ranksX.reduce((a, b) => a + b, 0) / n;
+    const meanRY = ranksY.reduce((a, b) => a + b, 0) / n;
+    let numeratorS = 0;
+    let denomSX = 0;
+    let denomSY = 0;
+    for (let i = 0; i < n; i++) {
+        const diffRX = ranksX[i] - meanRX;
+        const diffRY = ranksY[i] - meanRY;
+        numeratorS += diffRX * diffRY;
+        denomSX += diffRX * diffRX;
+        denomSY += diffRY * diffRY;
+    }
+    const denomS = Math.sqrt(denomSX * denomSY);
+    const spearmanR = denomS === 0 ? 0 : numeratorS / denomS;
+    return spearmanR;
+}
+/**
+ * Calculates the coefficient of determination (R²) and the coefficient of alienation (1 - R²) based on the Pearson correlation coefficient (r).
+ * The coefficient of determination (R²) indicates the proportion of the variance in the dependent variable that is predictable from the independent variable.
+ * The coefficient of alienation (1 - R²) indicates the proportion of the variance that is not explained by the model.
+ *
+ * @param pearsonR The Pearson correlation coefficient (r) between two datasets.
+ * @returns An object containing the coefficient of determination (R²) and the coefficient of alienation (1 - R²).
+ */
+function determinationAndAlienation(pearsonR) {
+    const determination = pearsonR * pearsonR;
+    const alienation = 1 - determination;
+    return { determination, alienation };
+}
+/**
+ * Calculates the standard deviation of a dataset.
+ * The standard deviation is a measure of the amount of variation or dispersion in a set of values.
+ * @param data An array of numbers representing the dataset.
+ * @returns The standard deviation of the dataset.
+ */
+function standardDeviation(data) {
+    if (data.length === 0)
+        return 0;
+    const mu = mean(data);
+    const variance = data.reduce((acc, val) => acc + (val - mu) ** 2, 0) / data.length;
+    return Math.sqrt(variance);
+}
+/**
+ * Calculates the standard deviation from histogram data.
+ * The standard deviation is a measure of the amount of variation or dispersion in a set of values.
+ * This function uses the total count, total sum, and total sum of squares to compute the standard deviation.
+ * @param totalCount The total number of occurrences across all histogram buckets.
+ * @param totalSum The total sum of all values across the histogram buckets.
+ * @param totalSumOfSquares The total sum of squares of all values across the histogram buckets.
+ * @returns The standard deviation of the histogram data.
+ */
+function standardDeviationHistogram(totalCount, totalSum, totalSumOfSquares) {
+    if (totalCount === 0)
+        return 0;
+    const mean = totalSum / totalCount;
+    const variance = (totalSumOfSquares / totalCount) - (mean ** 2);
+    return Math.sqrt(Math.max(0, variance));
+}
+/**
+ * Calculates the z-score for a given value based on the mean and standard deviation of a dataset.
+ * The z-score indicates how many standard deviations a value is from the mean.
+ * A positive z-score indicates the value is above the mean, while a negative z-score indicates it is below the mean.
+ * @param value The value for which the z-score is to be calculated.
+ * @param data An array of numbers representing the dataset.
+ * @returns The z-score of the value. If the dataset is empty or has zero standard deviation, the function returns 0.
+ */
+function zScore(value, data) {
+    if (data.length === 0)
+        return 0;
+    const mu = mean(data);
+    const sigma = standardDeviation(data);
+    if (sigma === 0)
+        return 0;
+    return (value - mu) / sigma;
+}
+/**
+ * Calculates the z-score for a given value based on histogram data.
+ * The z-score indicates how many standard deviations a value is from the mean.
+ * A positive z-score indicates the value is above the mean, while a negative z-score indicates it is below the mean.
+ * @param value The value for which the z-score is to be calculated.
+ * @param totalCount The total number of occurrences across all histogram buckets.
+ * @param totalSum The total sum of all values across the histogram buckets.
+ * @param totalSumOfSquares The total sum of squares of all values across the histogram buckets.
+ * @returns The z-score of the value. If the histogram is empty or has zero standard deviation, the function returns 0.
+ */
+function zScoreHistogram(value, totalCount, totalSum, totalSumOfSquares) {
+    if (totalCount === 0)
+        return 0;
+    const mu = totalSum / totalCount;
+    const sigma = standardDeviationHistogram(totalCount, totalSum, totalSumOfSquares);
+    if (sigma === 0)
+        return 0;
+    return (value - mu) / sigma;
+}
+/**
+ * Determines if a given value is an anomaly based on its z-score relative to a dataset.
+ * A value is considered an anomaly if its z-score exceeds the specified threshold.
+ * @param value The value to be evaluated for anomaly detection.
+ * @param data An array of numbers representing the dataset against which the value is compared.
+ * @param threshold The z-score threshold beyond which a value is considered an anomaly. Default is 3.
+ * @returns A boolean indicating whether the value is an anomaly (true) or not (false).
+ */
+function isDataAnomaly(value, data, threshold = 3) {
+    const z = zScore(value, data);
+    return Math.abs(z) > threshold;
+}
+/**
+ * Determines if a given value is an anomaly based on its z-score relative to histogram data.
+ * A value is considered an anomaly if its z-score exceeds the specified threshold.
+ * @param value The value to be evaluated for anomaly detection.
+ * @param totalCount The total number of occurrences across all histogram buckets.
+ * @param totalSum The total sum of all values across the histogram buckets.
+ * @param totalSumOfSquares The total sum of squares of all values across the histogram buckets.
+ * @param threshold The z-score threshold beyond which a value is considered an anomaly. Default is 3.
+ * @returns A boolean indicating whether the value is an anomaly (true) or not (false).
+ */
+function isDataAnomalyHistogram(value, totalCount, totalSum, totalSumOfSquares, threshold = 3) {
+    const z = zScoreHistogram(value, totalCount, totalSum, totalSumOfSquares);
+    return Math.abs(z) > threshold;
+}

package/dist/express/index.d.ts

@@ -0,0 +1,6 @@
+import express from 'express';
+import { Server as HTTPServer } from 'http';
+import { type ConfigOptions } from '../config';
+export declare function setupOptima(app: express.Express, options?: ConfigOptions): {
+    attachServer: (server: HTTPServer) => () => void;
+};

package/dist/express/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupOptima = setupOptima;
+const config_1 = require("../config");
+const metrics_middleware_1 = require("./metrics.middleware");
+const metrics_dashboard_1 = require("./metrics.dashboard");
+const metrics_bootstrap_1 = require("./metrics.bootstrap");
+function setupOptima(app, options) {
+    config_1.ConfigManager.getInstance().initialize(options);
+    const config = config_1.ConfigManager.getInstance().get();
+    // Registering the metrics middleware
+    app.use(metrics_middleware_1.expressMetricsMiddleware);
+    // Attaching the dashboard on provided path
+    if (config.dashboardPath !== false) {
+        (0, metrics_dashboard_1.attachDashboard)(app, config.dashboardPath);
+    }
+    return {
+        attachServer: (server) => {
+            return (0, metrics_bootstrap_1.expressMetricsBootstrap)(server);
+        }
+    };
+}

package/dist/express/metrics-websocket.adapter.d.ts

@@ -0,0 +1,14 @@
+import type { Server as HTTPServer } from 'http';
+import type { WebSocketAdapter } from '../adapters/websocket.adapter';
+import { type MetricsDataProvider } from '../core/delivery';
+export declare class ExpressWebSocketAdapter implements WebSocketAdapter {
+    private readonly server;
+    private readonly provider;
+    private io?;
+    constructor(server: HTTPServer, provider: MetricsDataProvider);
+    init(): void;
+    private setupEvents;
+    private setupClient;
+    broadcast(event: string, data: unknown): void;
+    disconnect(): void;
+}

package/dist/express/metrics-websocket.adapter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressWebSocketAdapter = void 0;
+const socket_io_1 = require("socket.io");
+const delivery_1 = require("../core/delivery");
+const config_1 = require("../config");
+class ExpressWebSocketAdapter {
+    server;
+    provider;
+    io;
+    constructor(server, provider) {
+        this.server = server;
+        this.provider = provider;
+    }
+    init() {
+        if (this.io) {
+            console.warn('[Optima] WebSocket server is already initialized.');
+            return;
+        }
+        this.io = new socket_io_1.Server(this.server, {
+            transports: ['websocket'],
+            maxHttpBufferSize: 1e8, // 100MB
+            pingTimeout: 10000, // 10 seconds
+            pingInterval: 25000, // 25 seconds
+            cors: {
+                origin: '*',
+                methods: ['GET', 'POST'],
+            },
+        });
+        console.log('[Optima] WebSocket server initialized successfully.');
+        this.setupEvents();
+    }
+    setupEvents() {
+        if (!this.io)
+            return;
+        console.log('[Optima] Setting up WebSocket event bindings.');
+        this.io.on('connection', socket => {
+            console.log(`[Optima] New WebSocket connection: ${socket.id}`);
+            this.setupClient(socket);
+        });
+    }
+    setupClient(socket) {
+        socket.on(delivery_1.WebSocketEvents.REQUEST_CONFIGURATION, () => {
+            socket.emit(delivery_1.WebSocketEvents.RESPONSE_CONFIGURATION, config_1.ConfigManager.getInstance().get());
+        });
+        socket.on(delivery_1.WebSocketEvents.REQUEST_SYSTEM_DATA, () => {
+            socket.emit(delivery_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, this.provider.getSystemStaticInfo());
+        });
+        socket.on(delivery_1.WebSocketEvents.REQUEST_DASHBOARD_DATA, () => {
+            socket.emit(delivery_1.WebSocketEvents.RESPONSE_DASHBOARD_DATA, this.provider.getDashboardData());
+        });
+        socket.on(delivery_1.WebSocketEvents.REQUEST_ANALYTICS_DATA, () => {
+            socket.emit(delivery_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, this.provider.getAnalyticsData());
+        });
+        socket.on(delivery_1.WebSocketEvents.REQUEST_HEALTH_DATA, () => {
+            socket.emit(delivery_1.WebSocketEvents.RESPONSE_HEALTH_DATA, this.provider.getHealthData());
+        });
+        socket.on('disconnect', () => {
+            console.log(`[Optima] WebSocket disconnected: ${socket.id}`);
+        });
+    }
+    broadcast(event, data) {
+        this.io?.emit(event, data);
+    }
+    disconnect() {
+        this.io?.close();
+        this.io = undefined;
+    }
+}
+exports.ExpressWebSocketAdapter = ExpressWebSocketAdapter;

package/dist/express/metrics.adapter.d.ts

@@ -0,0 +1,12 @@
+import type { Request, Response } from 'express';
+import type { HttpAdapter } from '../adapters/http.adapter';
+export declare class ExpressAdapter implements HttpAdapter<Request, Response> {
+    getRequest(request: Request): {
+        method: string;
+        endpoint: string;
+        clientIp: string | undefined;
+    };
+    getResponse(response: Response): {
+        statusCode: number;
+    };
+}

package/dist/express/metrics.adapter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapter = void 0;
+class ExpressAdapter {
+    getRequest(request) {
+        const { body, // Parsed JSON or form data
+        params, // Route path variables
+        query, // URL query string parameters
+        headers, // HTTP request headers
+        cookies, // Parsed client browser cookies
+        method, // Executed HTTP verb (GET, POST, etc.)
+        path, // Requested URL path string
+        ip, // Remote client IP address
+        secure, // Boolean for TLS connection status
+        url, // Full requested URL string
+         } = request;
+        return {
+            method,
+            endpoint: path,
+            clientIp: ip,
+        };
+    }
+    getResponse(response) {
+        const { locals, // Request-scoped middleware variables
+        headersSent, // Boolean tracking sent HTTP headers
+        statusCode, // Current HTTP status code
+         } = response;
+        return { statusCode };
+    }
+}
+exports.ExpressAdapter = ExpressAdapter;

package/dist/express/metrics.bootstrap.d.ts

@@ -0,0 +1,2 @@
+import { Server as HTTPServer } from 'http';
+export declare function expressMetricsBootstrap(server: HTTPServer): () => void;

package/dist/express/metrics.bootstrap.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressMetricsBootstrap = expressMetricsBootstrap;
+const metrics_websocket_adapter_1 = require("./metrics-websocket.adapter");
+const collector_service_1 = require("../core/telemetry/collector.service");
+const simulation_1 = require("../simulation/simulation");
+const delivery_1 = require("../core/delivery");
+const correlation_service_1 = require("../core/telemetry/correlation.service");
+const config_1 = require("../config");
+function expressMetricsBootstrap(server) {
+    const config = (0, config_1.getConfig)();
+    let simulator = null;
+    if (config.simulation) {
+        simulator = new simulation_1.TrafficSimulator();
+        simulator.start({
+            intervalMs: config.simulation.intervalMs,
+            requestsPerTick: config.simulation.requestsPerTick,
+        });
+    }
+    const websocket = new metrics_websocket_adapter_1.ExpressWebSocketAdapter(server, collector_service_1.collectorService);
+    websocket.init();
+    const publisher = new delivery_1.MetricsPublisher(collector_service_1.collectorService, websocket, config.publisher.intervalMs);
+    publisher.start();
+    const tickInterval = setInterval(() => {
+        collector_service_1.collectorService.tick();
+        correlation_service_1.correlationService.tick();
+    }, config.tickIntervalMs);
+    console.log('[Optima] Uspešno inicijalizovani svi podsistemi monitoringa.');
+    return () => {
+        simulator?.stop();
+        publisher.stop();
+        clearInterval(tickInterval);
+        websocket.disconnect();
+    };
+}

package/dist/express/metrics.dashboard.d.ts

@@ -0,0 +1,2 @@
+import express from 'express';
+export declare function attachDashboard(app: express.Express, routePath?: string): void;

package/dist/express/metrics.dashboard.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachDashboard = attachDashboard;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+function attachDashboard(app, routePath = '/dashboard') {
+    const staticAssetsPath = path_1.default.resolve(__dirname, '../../../dashboard/out');
+    app.use(routePath, express_1.default.static(staticAssetsPath));
+    app.get(`${routePath}/*`, (req, res) => {
+        res.sendFile(path_1.default.join(staticAssetsPath, 'index.html'));
+    });
+}

package/dist/express/metrics.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'express';
+export declare const expressMetricsMiddleware: RequestHandler;

package/dist/express/metrics.middleware.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressMetricsMiddleware = void 0;
+const telemetry_service_1 = __importDefault(require("../core/telemetry/telemetry.service"));
+const logger_1 = __importDefault(require("../core/telemetry/logger"));
+const metrics_adapter_1 = require("./metrics.adapter");
+const telemetryService = new telemetry_service_1.default();
+const adapter = new metrics_adapter_1.ExpressAdapter();
+const expressMetricsMiddleware = (req, res, next) => {
+    const startHrTime = process.hrtime.bigint();
+    res.on('finish', () => {
+        const requestData = adapter.getRequest(req);
+        const responseData = adapter.getResponse(res);
+        const telemetryRequest = telemetryService.record({
+            endpoint: requestData.endpoint,
+            method: requestData.method,
+            statusCode: responseData.statusCode,
+            clientIp: requestData.clientIp
+        }, startHrTime);
+        if (telemetryRequest !== null) {
+            logger_1.default.log(req, res, telemetryRequest.responseTime);
+        }
+    });
+    next();
+};
+exports.expressMetricsMiddleware = expressMetricsMiddleware;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { HttpAdapter, RequestRequiredData, ResponseRequiredData } from './adapters/http.adapter';
+export type { WebSocketAdapter } from './adapters/websocket.adapter';
+export declare function getHelloMetrics(): string;

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHelloMetrics = getHelloMetrics;
+function getHelloMetrics() {
+    return "Metrics Pack is greeting you!";
+}

package/dist/nest/index.d.ts

@@ -0,0 +1,4 @@
+export { MetricsInterceptor } from './metrics.interceptor';
+export { MetricsModule } from './metrics.module';
+export { NestAdapter } from './metrics.adapter';
+export { NestWebSocketAdapter } from './metrics-websocket.adapter';

package/dist/nest/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestWebSocketAdapter = exports.NestAdapter = exports.MetricsModule = exports.MetricsInterceptor = void 0;
+var metrics_interceptor_1 = require("./metrics.interceptor");
+Object.defineProperty(exports, "MetricsInterceptor", { enumerable: true, get: function () { return metrics_interceptor_1.MetricsInterceptor; } });
+var metrics_module_1 = require("./metrics.module");
+Object.defineProperty(exports, "MetricsModule", { enumerable: true, get: function () { return metrics_module_1.MetricsModule; } });
+var metrics_adapter_1 = require("./metrics.adapter");
+Object.defineProperty(exports, "NestAdapter", { enumerable: true, get: function () { return metrics_adapter_1.NestAdapter; } });
+var metrics_websocket_adapter_1 = require("./metrics-websocket.adapter");
+Object.defineProperty(exports, "NestWebSocketAdapter", { enumerable: true, get: function () { return metrics_websocket_adapter_1.NestWebSocketAdapter; } });

package/dist/nest/metrics-websocket.adapter.d.ts

@@ -0,0 +1,15 @@
+import { OnGatewayConnection, OnGatewayDisconnect } from '@nestjs/websockets';
+import type { Socket } from 'socket.io';
+import type { WebSocketAdapter } from '../adapters/websocket.adapter';
+export declare class NestWebSocketAdapter implements WebSocketAdapter, OnGatewayConnection, OnGatewayDisconnect {
+    private server;
+    init(): void;
+    handleConnection(socket: Socket): void;
+    handleDisconnect(socket: Socket): void;
+    handleSystemData(socket: Socket): void;
+    handleDashboardData(socket: Socket): void;
+    handleAnalyticsData(socket: Socket): void;
+    handleHealthData(socket: Socket): void;
+    broadcast(event: string, data: unknown): void;
+    disconnect(): void;
+}