apm-optima 0.0.1

package/dist/core/storage/stores/endpoint.store.d.ts

@@ -0,0 +1,16 @@
+import type { EndpointTelemetry } from "../../domain";
+declare class EndpointStore {
+    private readonly endpoints;
+    private createKey;
+    record(input: {
+        method: string;
+        route: string;
+        duration: number;
+        statusCode: number;
+    }): void;
+    get(method: string, route: string): EndpointTelemetry | undefined;
+    all(): EndpointTelemetry[];
+    private map;
+    reset(): void;
+}
+export { EndpointStore };

package/dist/core/storage/stores/endpoint.store.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointStore = void 0;
+const utility_1 = require("../utility");
+class EndpointStore {
+    endpoints = new Map();
+    createKey(method, route) {
+        return `${method}:${route}`;
+    }
+    record(input) {
+        const key = this.createKey(input.method, input.route);
+        let endpoint = this.endpoints.get(key);
+        if (!endpoint) {
+            endpoint = {
+                method: input.method,
+                route: input.route,
+                requestCount: 0,
+                errorCount: 0,
+                totalLatency: 0,
+                histogram: new utility_1.Histogram(),
+                lastRequestAt: Date.now(),
+            };
+            this.endpoints.set(key, endpoint);
+        }
+        endpoint.requestCount++;
+        endpoint.totalLatency += input.duration;
+        endpoint.lastRequestAt = Date.now();
+        endpoint.histogram.record(input.duration);
+        if (input.statusCode >= 400) {
+            endpoint.errorCount++;
+        }
+    }
+    get(method, route) {
+        const endpoint = this.endpoints.get(this.createKey(method, route));
+        if (!endpoint) {
+            return undefined;
+        }
+        return this.map(endpoint);
+    }
+    all() {
+        return [...this.endpoints.values()].map(endpoint => this.map(endpoint));
+    }
+    map(endpoint) {
+        const histogram = endpoint.histogram.snapshot();
+        return {
+            method: endpoint.method,
+            route: endpoint.route,
+            rps: endpoint.requestCount - histogram.count, //????
+            // calculated later from buckets
+            requestCount: endpoint.requestCount,
+            averageLatency: endpoint.requestCount === 0 ? 0 : endpoint.totalLatency / endpoint.requestCount,
+            p95: histogram.p95,
+            p99: histogram.p99,
+            errorRate: endpoint.requestCount === 0 ? 0 : endpoint.errorCount / endpoint.requestCount,
+            status: endpoint.errorCount > 0 ? "DEGRADED" : "HEALTHY",
+        };
+    }
+    reset() {
+        this.endpoints.clear();
+    }
+}
+exports.EndpointStore = EndpointStore;

package/dist/core/storage/stores/health.store.d.ts

@@ -0,0 +1,20 @@
+import type { EventLoopMetrics, MemoryMetrics, V8RuntimeInfo, LibuvHandles, HealthData, CpuMetrics, GCMetrics } from "../../domain";
+declare class HealthStore {
+    private cpu;
+    private memory;
+    private eventLoop;
+    private handles;
+    private garbageCollection;
+    private runtime;
+    private readonly history;
+    constructor(bufferSize?: number, eventLoopLagThreshold?: number);
+    updateCPU(cpu: CpuMetrics): void;
+    updateMemory(memory: MemoryMetrics): void;
+    updateEventLoop(eventLoop: EventLoopMetrics): void;
+    updateHandles(handles: LibuvHandles): void;
+    updateGC(gc: GCMetrics): void;
+    updateRuntime(runtime: V8RuntimeInfo): void;
+    get(): HealthData;
+    resetHistory(): void;
+}
+export { HealthStore };

package/dist/core/storage/stores/health.store.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthStore = void 0;
+const utility_1 = require("../utility");
+class HealthStore {
+    cpu;
+    memory;
+    eventLoop;
+    handles;
+    garbageCollection;
+    runtime;
+    history;
+    constructor(bufferSize = 60, eventLoopLagThreshold = 100) {
+        this.history = {
+            eventLoopLag: new utility_1.RingBuffer(bufferSize),
+            usedHeap: new utility_1.RingBuffer(bufferSize),
+            totalHeap: new utility_1.RingBuffer(bufferSize),
+            rssMemory: new utility_1.RingBuffer(bufferSize),
+        };
+        this.cpu = {
+            usageRate: 0,
+            numberOfCores: 0,
+            perCoreUsage: [],
+            userUsage: 0,
+            systemUsage: 0,
+            idleUsage: 0,
+        };
+        this.memory = {
+            heapUsage: 0,
+            heapSize: 0,
+            rssMemory: 0,
+            rssMemoryTotal: 0,
+            externalMemory: 0,
+        };
+        this.eventLoop = {
+            lag: 0,
+            threshold: eventLoopLagThreshold,
+        };
+        this.handles = {
+            activeHandles: 0,
+            activeHandlesTimers: 0,
+            activeHandlesSockets: 0,
+            activeLibuvHandles: 0,
+            timers: 0,
+            fileDescriptors: 0,
+        };
+        this.garbageCollection = {
+            gcCount: 0,
+            gcTime: 0,
+            gcPauseAverage: 0,
+            minorGC: {
+                runCount: 0,
+                averageTime: 0,
+            },
+            majorGC: {
+                runCount: 0,
+                averageTime: 0,
+            },
+            incrementalGC: {
+                runCount: 0,
+                averageTime: 0,
+            },
+            heapSpaces: [],
+            gcTotals: {
+                totalPauseTime: 0,
+                freedMemory: 0,
+                promotions: 0,
+                tenuredSize: 0,
+            },
+        };
+        this.runtime = {
+            pid: process.pid,
+            platform: process.platform,
+            nodeVersion: process.version,
+            v8Version: process.versions.v8,
+            libuvVersion: process.versions.uv,
+            openSSLVersion: process.versions.openssl,
+            threadPoolSize: 0,
+            activeThreads: 0,
+            startup: {
+                bootstrapTime: 0,
+                requiredModules: 0,
+            },
+        };
+    }
+    updateCPU(cpu) {
+        this.cpu = cpu;
+    }
+    updateMemory(memory) {
+        this.memory = memory;
+        this.history.usedHeap.push(memory.heapUsage);
+        this.history.totalHeap.push(memory.heapSize);
+        this.history.rssMemory.push(memory.rssMemory);
+    }
+    updateEventLoop(eventLoop) {
+        this.eventLoop = eventLoop;
+        this.history.eventLoopLag.push(eventLoop.lag);
+    }
+    updateHandles(handles) {
+        this.handles = handles;
+    }
+    updateGC(gc) {
+        this.garbageCollection = gc;
+    }
+    updateRuntime(runtime) {
+        this.runtime = runtime;
+    }
+    get() {
+        return {
+            cpu: this.cpu,
+            memory: this.memory,
+            eventLoop: this.eventLoop,
+            handles: this.handles,
+            garbageCollection: this.garbageCollection,
+            runtime: this.runtime,
+            history: {
+                eventLoopLag: this.history.eventLoopLag.values(),
+                memoryBreakdown: {
+                    usedHeap: this.history.usedHeap.values(),
+                    totalHeap: this.history.totalHeap.values(),
+                    rssMemory: this.history.rssMemory.values(),
+                }
+            }
+        };
+    }
+    resetHistory() {
+        this.history.eventLoopLag.clear();
+        this.history.usedHeap.clear();
+        this.history.totalHeap.clear();
+        this.history.rssMemory.clear();
+    }
+}
+exports.HealthStore = HealthStore;

package/dist/core/storage/stores/index.d.ts

@@ -0,0 +1,8 @@
+export * from './alert.store';
+export * from './analytics.store';
+export * from './dashboard.store';
+export * from './endpoint.store';
+export * from './health.store';
+export * from './metrics.store';
+export * from './system.store';
+export * from './bucket.store';

package/dist/core/storage/stores/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./alert.store"), exports);
+__exportStar(require("./analytics.store"), exports);
+__exportStar(require("./dashboard.store"), exports);
+__exportStar(require("./endpoint.store"), exports);
+__exportStar(require("./health.store"), exports);
+__exportStar(require("./metrics.store"), exports);
+__exportStar(require("./system.store"), exports);
+__exportStar(require("./bucket.store"), exports);

package/dist/core/storage/stores/metrics.store.d.ts

@@ -0,0 +1,23 @@
+import { HistogramSnapshot } from '../utility';
+export interface MetricsSnapshot {
+    requestCount: number;
+    errorClientCount: number;
+    errorServerCount: number;
+    averageLatency: number;
+    errorRate: number;
+    latency: HistogramSnapshot;
+}
+export declare class MetricsStore {
+    private requestCount;
+    private errorClientCount;
+    private errorServerCount;
+    private totalLatency;
+    private readonly histogram;
+    constructor();
+    record(input: {
+        duration: number;
+        statusCode: number;
+    }): "SUCCESS" | "FAILED" | "ANOMALY";
+    snapshot(): MetricsSnapshot;
+    reset(): void;
+}

package/dist/core/storage/stores/metrics.store.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsStore = void 0;
+const utility_1 = require("../utility");
+class MetricsStore {
+    requestCount;
+    errorClientCount;
+    errorServerCount;
+    totalLatency;
+    histogram;
+    constructor() {
+        this.requestCount = 0;
+        this.errorClientCount = 0;
+        this.errorServerCount = 0;
+        this.totalLatency = 0;
+        this.histogram = new utility_1.Histogram();
+    }
+    record(input) {
+        this.requestCount++;
+        this.totalLatency += input.duration;
+        const status = this.histogram.record(input.duration);
+        if (input.statusCode >= 400 && input.statusCode < 500) {
+            this.errorClientCount++;
+        }
+        else if (input.statusCode >= 500) {
+            this.errorServerCount++;
+        }
+        return status;
+    }
+    snapshot() {
+        const latency = this.histogram.snapshot();
+        return {
+            requestCount: this.requestCount,
+            errorClientCount: this.errorClientCount,
+            errorServerCount: this.errorServerCount,
+            averageLatency: this.requestCount === 0 ? 0 : this.totalLatency / this.requestCount,
+            errorRate: this.requestCount === 0 ? 0 : (this.errorClientCount + this.errorServerCount) / this.requestCount,
+            latency,
+        };
+    }
+    reset() {
+        this.requestCount = 0;
+        this.errorClientCount = 0;
+        this.errorServerCount = 0;
+        this.totalLatency = 0;
+        this.histogram.reset();
+    }
+}
+exports.MetricsStore = MetricsStore;

package/dist/core/storage/stores/system.store.d.ts

@@ -0,0 +1,8 @@
+import type { SystemStaticInfo } from '../../domain';
+declare class SystemStore {
+    private readonly env;
+    private readonly startedAt;
+    constructor(env?: string);
+    get(): SystemStaticInfo;
+}
+export { SystemStore };

package/dist/core/storage/stores/system.store.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemStore = void 0;
+class SystemStore {
+    env;
+    startedAt;
+    constructor(env = process.env.NODE_ENV ?? "unknown") {
+        this.env = env;
+        this.startedAt = Date.now();
+    }
+    get() {
+        return {
+            uptime: Date.now() - this.startedAt,
+            nodeVersion: process.version,
+            env: this.env,
+        };
+    }
+}
+exports.SystemStore = SystemStore;

package/dist/core/storage/utility/histogram.d.ts

@@ -0,0 +1,37 @@
+export interface HistogramSnapshot {
+    buckets: number[];
+    count: number;
+    sum: number;
+    average: number;
+    sumOfSquares: number;
+    p50: number;
+    p95: number;
+    p99: number;
+    anomalyCount: number;
+}
+type RecordStatus = 'SUCCESS' | 'FAILED' | 'ANOMALY';
+export declare class Histogram {
+    private readonly anomalySampleSize;
+    private readonly anomalyLowerLimit;
+    private readonly limits;
+    private readonly counters;
+    private totalCount;
+    private totalSum;
+    private totalSumOfSquares;
+    private anomalyCount;
+    constructor(anomalySampleSize?: number, //! For this use calculation
+    anomalyLowerLimit?: number);
+    record(durationMs: number): RecordStatus;
+    snapshot(): HistogramSnapshot;
+    private percentile;
+    private checkIfAnomaly;
+    reset(): void;
+}
+/**
+ * Calculates the tolerance for a given value based on the provided histogram limits.
+ * @param value The value for which to calculate the tolerance.
+ * @param limits An array of upper limits for each histogram bucket.
+ * @returns The tolerance for the given value, which is the difference between the upper and lower limits of the bucket that contains the value.
+ */
+export declare function getBucketTolerance(value: number, limits: number[]): number;
+export {};

package/dist/core/storage/utility/histogram.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Histogram = void 0;
+exports.getBucketTolerance = getBucketTolerance;
+const utility_1 = require("../../utility");
+class Histogram {
+    anomalySampleSize;
+    anomalyLowerLimit;
+    limits = [
+        5, 10, 15, 20, 25, 30, 40, 50, 60, 70, 80, 90, 100,
+        120, 140, 160, 180, 200, 250, 300, 350, 400, 450, 500,
+        550, 600, 700, 800, 900, 1000, 1500, 2000, 3000, 5000,
+        Infinity,
+    ];
+    counters;
+    totalCount = 0;
+    totalSum = 0;
+    totalSumOfSquares = 0;
+    anomalyCount = 0;
+    constructor(anomalySampleSize = 60, //! For this use calculation
+    anomalyLowerLimit = 180) {
+        this.anomalySampleSize = anomalySampleSize;
+        this.anomalyLowerLimit = anomalyLowerLimit;
+        this.counters = new Uint32Array(this.limits.length);
+    }
+    record(durationMs) {
+        const isAnomaly = this.checkIfAnomaly(durationMs);
+        this.totalCount++;
+        this.totalSum += durationMs;
+        this.totalSumOfSquares += durationMs * durationMs;
+        for (let i = 0; i < this.limits.length; i++) {
+            if (durationMs <= this.limits[i]) {
+                this.counters[i]++;
+                break;
+            }
+        }
+        return isAnomaly ? 'ANOMALY' : 'SUCCESS';
+    }
+    snapshot() {
+        return {
+            buckets: Array.from(this.counters),
+            count: this.totalCount,
+            sum: this.totalSum,
+            average: this.totalCount === 0 ? 0 : this.totalSum / this.totalCount,
+            sumOfSquares: this.totalSumOfSquares,
+            p50: this.percentile(0.50),
+            p95: this.percentile(0.95),
+            p99: this.percentile(0.99),
+            anomalyCount: this.anomalyCount,
+        };
+    }
+    percentile(percent) {
+        return (0, utility_1.percentileHistogram)(this.counters, this.totalCount, percent, this.limits);
+    }
+    checkIfAnomaly(durationMs) {
+        if (this.totalCount < this.anomalySampleSize ||
+            durationMs < this.anomalyLowerLimit)
+            return false;
+        const isAnomaly = (0, utility_1.isDataAnomalyHistogram)(durationMs, this.totalCount, this.totalSum, this.totalSumOfSquares);
+        if (isAnomaly) {
+            this.anomalyCount++;
+            return true;
+        }
+        return false;
+    }
+    reset() {
+        this.counters.fill(0);
+        this.totalCount = 0;
+        this.totalSum = 0;
+        this.totalSumOfSquares = 0;
+        this.anomalyCount = 0;
+    }
+}
+exports.Histogram = Histogram;
+/**
+ * Calculates the tolerance for a given value based on the provided histogram limits.
+ * @param value The value for which to calculate the tolerance.
+ * @param limits An array of upper limits for each histogram bucket.
+ * @returns The tolerance for the given value, which is the difference between the upper and lower limits of the bucket that contains the value.
+ */
+function getBucketTolerance(value, limits) {
+    let lower = 0;
+    for (const limit of limits) {
+        if (value <= limit) {
+            const upper = Number.isFinite(limit) ? limit : lower;
+            return (upper - lower) + upper * 0.2; // 20% of the upper limit
+        }
+        lower = limit;
+    }
+    return 0;
+}

package/dist/core/storage/utility/index.d.ts

@@ -0,0 +1,2 @@
+export * from './histogram';
+export * from './ring-buffer';

package/dist/core/storage/utility/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./histogram"), exports);
+__exportStar(require("./ring-buffer"), exports);

package/dist/core/storage/utility/ring-buffer.d.ts

@@ -0,0 +1,12 @@
+export declare class RingBuffer<T> {
+    private readonly capacity;
+    private readonly buffer;
+    private index;
+    private count;
+    constructor(capacity: number);
+    push(value: T): void;
+    values(): T[];
+    latest(): T | undefined;
+    clear(): void;
+    size(): number;
+}

package/dist/core/storage/utility/ring-buffer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingBuffer = void 0;
+class RingBuffer {
+    capacity;
+    buffer;
+    index = 0;
+    count = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buffer = new Array(capacity);
+    }
+    push(value) {
+        this.buffer[this.index] = value;
+        this.index = (this.index + 1) % this.capacity;
+        if (this.count < this.capacity) {
+            this.count++;
+        }
+    }
+    values() {
+        if (this.count === 0) {
+            return [];
+        }
+        if (this.count < this.capacity) {
+            return this.buffer.slice(0, this.count);
+        }
+        return [
+            ...this.buffer.slice(this.index),
+            ...this.buffer.slice(0, this.index),
+        ];
+    }
+    latest() {
+        if (this.count === 0) {
+            return undefined;
+        }
+        const position = (this.index - 1 + this.capacity) % this.capacity;
+        return this.buffer[position];
+    }
+    clear() {
+        this.index = 0;
+        this.count = 0;
+    }
+    size() {
+        return this.count;
+    }
+}
+exports.RingBuffer = RingBuffer;

package/dist/core/telemetry/collector.service.d.ts

@@ -0,0 +1,18 @@
+import type { SystemStaticInfo, AnalyticsData, DashboardData, HealthData } from '../domain';
+import { CPUCollector, MemoryCollector, EventLoopCollector, GCCollector, HandlesCollector, RuntimeCollector } from './collectors';
+declare class CollectorService {
+    private readonly cpuCollector;
+    private readonly memoryCollector;
+    private readonly eventLoopCollector;
+    private readonly gcCollector;
+    private readonly handlesCollector;
+    private readonly runtimeCollector;
+    constructor(cpuCollector: CPUCollector, memoryCollector: MemoryCollector, eventLoopCollector: EventLoopCollector, gcCollector: GCCollector, handlesCollector: HandlesCollector, runtimeCollector: RuntimeCollector);
+    getSystemStaticInfo(): SystemStaticInfo;
+    getDashboardData(): DashboardData;
+    getAnalyticsData(): AnalyticsData;
+    getHealthData(): HealthData;
+    tick(): void;
+}
+export declare const collectorService: CollectorService;
+export {};