apm-optima 0.0.1

package/dist/core/domain/metrics.types.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Represents CPU metrics, including usage rate, number of cores, per-core usage, and breakdown of user, system, and idle usage.
+ * @property {number} usageRate - The overall CPU usage rate (as a percentage).
+ * @property {number} numberOfCores - The total number of CPU cores.
+ * @property {number[]} perCoreUsage - An array representing the usage rate for each individual core (as percentages).
+ * @property {number} userUsage - The CPU usage attributed to user processes (as a percentage).
+ * @property {number} systemUsage - The CPU usage attributed to system processes (as a percentage).
+ * @property {number} idleUsage - The CPU usage attributed to idle time (as a percentage).
+ */
+export interface CpuMetrics {
+    usageRate: number;
+    numberOfCores: number;
+    perCoreUsage: number[];
+    userUsage: number;
+    systemUsage: number;
+    idleUsage: number;
+}
+/**
+ * Represents memory metrics, including heap usage, heap size, resident set size (RSS) memory, total RSS memory, and external memory usage.
+ * @property {number} heapUsage - The amount of memory currently used by the V8 heap (in bytes).
+ * @property {number} heapSize - The total size of the V8 heap (in bytes).
+ * @property {number} rssMemory - The amount of resident set size (RSS) memory currently used by the process (in bytes).
+ * @property {number} rssMemoryTotal - The total amount of RSS memory available to the process (in bytes).
+ * @property {number} externalMemory - The amount of memory used by C++ objects bound to JavaScript objects managed by V8 (in bytes).
+ */
+export interface MemoryMetrics {
+    heapUsage: number;
+    heapSize: number;
+    rssMemory: number;
+    rssMemoryTotal: number;
+    externalMemory: number;
+}
+/**
+ * Represents event loop metrics, including the current lag and the threshold for acceptable lag.
+ * @property {number} lag - The current event loop lag (in milliseconds).
+ * @property {number} threshold - The threshold for acceptable event loop lag (in milliseconds).
+ */
+export interface EventLoopMetrics {
+    lag: number;
+    threshold: number;
+}
+/**
+ * Represents garbage collection (GC) metrics, including counts, times, pause averages, summaries for different GC types, heap space allocations, and overall GC totals.
+ * @property {number} gcCount - The total number of garbage collection runs.
+ * @property {number} gcTime - The total time spent in garbage collection (in milliseconds).
+ * @property {number} gcPauseAverage - The average pause time during garbage collection (in milliseconds).
+ * @property {GCRunSummary} minorGC - Summary metrics for minor garbage collections.
+ * @property {GCRunSummary} majorGC - Summary metrics for major garbage collections.
+ * @property {GCRunSummary} incrementalGC - Summary metrics for incremental garbage collections.
+ * @property {HeapSpaceAllocation[]} heapSpaces - An array of heap space allocations, each representing a specific heap space and its used memory.
+ * @property {GCTotals} gcTotals - Overall totals for garbage collection, including total pause time, freed memory, promotions, and tenured size.
+ */
+export interface GCMetrics {
+    gcCount: number;
+    gcTime: number;
+    gcPauseAverage: number;
+    minorGC: GCRunSummary;
+    majorGC: GCRunSummary;
+    incrementalGC: GCRunSummary;
+    heapSpaces: HeapSpaceAllocation[];
+    gcTotals: GCTotals;
+}
+interface GCRunSummary {
+    runCount: number;
+    averageTime: number;
+}
+interface HeapSpaceAllocation {
+    label: string;
+    used: number;
+}
+interface GCTotals {
+    totalPauseTime: number;
+    freedMemory: number;
+    promotions: number;
+    tenuredSize: number;
+}
+/**
+ * Represents libuv metrics, including counts of active handles, timers, sockets, and file descriptors.
+ * @property {number} activeHandles - The total number of active libuv handles.
+ * @property {number} activeHandlesTimers - The number of active libuv timer handles.
+ * @property {number} activeHandlesSockets - The number of active libuv socket handles.
+ * @property {number} activeLibuvHandles - The total number of active libuv handles (including timers and sockets).
+ * @property {number} timers - The total number of libuv timers.
+ * @property {number} fileDescriptors - The total number of file descriptors used by the process.
+ */
+export interface LibuvHandles {
+    activeHandles: number;
+    activeHandlesTimers: number;
+    activeHandlesSockets: number;
+    activeLibuvHandles: number;
+    timers: number;
+    fileDescriptors: number;
+}
+/**
+ * Represents historic time series data for various metrics, including requests per second (RPS), latency, error rate, event loop lag, heap usage, heap size, resident set size (RSS) memory, total heap memory, and optional percentiles (p95 and p99).
+ * @property {number[]} rps - An array of requests per second (RPS) values over time.
+ * @property {number[]} latency - An array of latency values over time.
+ * @property {number[]} errorRate - An array of error rate values over time.
+ * @property {number[]} eventLoopLag - An array of event loop lag values over time.
+ * @property {number[]} heapUsage - An array of heap usage values over time.
+ * @property {number[]} heapSize - An array of heap size values over time.
+ * @property {number[]} rssMemory - An array of resident set size (RSS) memory values over time.
+ * @property {number[]} totalHeap - An array of total heap memory values over time (from health memory breakdown).
+ * @property {number[]} [p95] - Optional array of 95th percentile latency values over time.
+ * @property {number[]} [p99] - Optional array of 99th percentile latency values over time.
+ */
+export interface HistoricTimeSeries {
+    rps: number[];
+    latency: number[];
+    errorRate: number[];
+    eventLoopLag: number[];
+    heapUsage: number[];
+    heapSize: number[];
+    rssMemory: number[];
+    totalHeap: number[];
+    p95?: number[];
+    p99?: number[];
+}
+export {};

package/dist/core/domain/metrics.types.js

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

package/dist/core/domain/system.types.d.ts

@@ -0,0 +1,51 @@
+import type { ConnectionStatus, HealthStatus } from './common.types';
+/**
+ * Represents the overall system status, including connection status, health status, and WebSocket connection status.
+ * @property {ConnectionStatus} connectionStatus - The current connection status of the system (ONLINE, OFFLINE, CONNECTING, DISCONNECTED).
+ * @property {HealthStatus} healthStatus - The current health status of the system (HEALTHY, DEGRADED, UNHEALTHY, UNKNOWN).
+ * @property {ConnectionStatus} webSocketStatus - The current WebSocket connection status (ONLINE, OFFLINE, CONNECTING, DISCONNECTED).
+ */
+export interface SystemStatus {
+    connectionStatus: ConnectionStatus;
+    healthStatus: HealthStatus;
+    webSocketStatus: ConnectionStatus;
+}
+/**
+ * Represents static information about the system, including uptime, Node.js version, and environment.
+ * @property {number} uptime - The system uptime in seconds.
+ * @property {string} nodeVersion - The version of Node.js running the system.
+ * @property {string} env - The current environment (e.g., 'development', 'production').
+ */
+export interface SystemStaticInfo {
+    uptime: number;
+    nodeVersion: string;
+    env: string;
+}
+/**
+ * Represents detailed information about the V8 runtime environment, including process ID, platform, Node.js version, V8 version, libuv version, OpenSSL version, thread pool size, active threads, and startup metrics.
+ * @property {number} pid - The process ID of the Node.js process.
+ * @property {string} platform - The operating system platform (e.g., 'linux', 'darwin', 'win32').
+ * @property {string} nodeVersion - The version of Node.js running the system.
+ * @property {string} v8Version - The version of the V8 JavaScript engine.
+ * @property {string} libuvVersion - The version of the libuv library used by Node.js.
+ * @property {string} openSSLVersion - The version of OpenSSL used by Node.js.
+ * @property {number} threadPoolSize - The size of the libuv thread pool.
+ * @property {number} activeThreads - The number of active threads in the thread pool.
+ * @property {object} startup - An object containing startup metrics, including bootstrap time and required modules count.
+ * @property {number} startup.bootstrapTime - The time taken for the Node.js process to bootstrap (in milliseconds).
+ * @property {number} startup.requiredModules - The number of modules required during startup.
+ */
+export interface V8RuntimeInfo {
+    pid: number;
+    platform: string;
+    nodeVersion: string;
+    v8Version: string;
+    libuvVersion: string;
+    openSSLVersion: string;
+    threadPoolSize: number;
+    activeThreads: number;
+    startup: {
+        bootstrapTime: number;
+        requiredModules: number;
+    };
+}

package/dist/core/domain/system.types.js

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

package/dist/core/domain/telemetry.types.d.ts

@@ -0,0 +1,8 @@
+export interface TelemetryRequest {
+    timestamp: number;
+    endpoint: string;
+    method: string;
+    statusCode: number;
+    responseTime: number;
+    clientIp?: string;
+}

package/dist/core/domain/telemetry.types.js

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

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

@@ -0,0 +1,3 @@
+export * from './stores';
+export * from './utility';
+export * from './local.repository';

package/dist/core/storage/index.js

@@ -0,0 +1,19 @@
+"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("./stores"), exports);
+__exportStar(require("./utility"), exports);
+__exportStar(require("./local.repository"), exports);

package/dist/core/storage/local.repository.d.ts

@@ -0,0 +1,17 @@
+import type { TelemetryRequest } from '../domain';
+import { BucketStore, DashboardStore, AnalyticsStore, HealthStore, SystemStore, EndpointStore, AlertStore, MetricsStore } from './stores';
+declare class LocalRepository {
+    readonly endpoint: EndpointStore;
+    readonly alerts: AlertStore;
+    readonly metrics: MetricsStore;
+    readonly health: HealthStore;
+    readonly bucket: BucketStore;
+    readonly dashboard: DashboardStore;
+    readonly analytics: AnalyticsStore;
+    readonly system: SystemStore;
+    constructor();
+    record(request: TelemetryRequest): void;
+    tick(): void;
+}
+export declare const storage: LocalRepository;
+export {};

package/dist/core/storage/local.repository.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = void 0;
+const config_1 = require("../../config");
+const stores_1 = require("./stores");
+class LocalRepository {
+    // Standard Stores
+    endpoint;
+    alerts;
+    metrics;
+    // Historics Store
+    health;
+    bucket;
+    // Core Stores
+    dashboard;
+    analytics;
+    system;
+    constructor() {
+        const config = (0, config_1.getConfig)();
+        // Standard 
+        this.endpoint = new stores_1.EndpointStore();
+        this.alerts = new stores_1.AlertStore(config.alertBufferSize);
+        this.metrics = new stores_1.MetricsStore();
+        // Historic
+        this.health = new stores_1.HealthStore(config.ringBufferSize, config.publisher.eventLoopLagThresholdMs);
+        this.bucket = new stores_1.BucketStore(this.endpoint, this.health, this.metrics, config.ringBufferSize);
+        this.dashboard = new stores_1.DashboardStore(this.bucket, this.health, this.endpoint, this.alerts);
+        this.analytics = new stores_1.AnalyticsStore(this.bucket, this.endpoint, config.publisher.slowLatencyThresholdMs);
+        this.system = new stores_1.SystemStore();
+    }
+    record(request) {
+        const data = {
+            method: request.method,
+            route: request.endpoint,
+            duration: request.responseTime,
+            statusCode: request.statusCode
+        };
+        this.endpoint.record(data);
+        const status = this.metrics.record({
+            duration: request.responseTime,
+            statusCode: request.statusCode
+        });
+        if (status === 'ANOMALY') {
+            this.alerts.warning(`Anomaly detected: ${request.method} ${request.endpoint} took ${request.responseTime}ms`);
+        }
+        this.bucket.recordRequest(request.method, request.endpoint);
+    }
+    tick() {
+        this.bucket.flush();
+    }
+}
+exports.storage = new LocalRepository();

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

@@ -0,0 +1,13 @@
+import type { AlertMessage } from '../../domain';
+declare class AlertStore {
+    private readonly alerts;
+    constructor(bufferSize?: number);
+    add(alert: AlertMessage): void;
+    critical(title: string): void;
+    warning(title: string): void;
+    info(title: string): void;
+    get(count?: number): AlertMessage[];
+    latest(): AlertMessage | undefined;
+    clear(): void;
+}
+export { AlertStore };

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertStore = void 0;
+const utility_1 = require("../utility");
+const SEVERITY_PRIORITY = {
+    info: 0,
+    advisory: 1,
+    warning: 2,
+    critical: 3,
+};
+class AlertStore {
+    alerts;
+    constructor(bufferSize = 100) {
+        this.alerts =
+            new utility_1.RingBuffer(bufferSize);
+    }
+    add(alert) {
+        this.alerts.push({
+            ...alert,
+            id: crypto.randomUUID(),
+        });
+    }
+    critical(title) {
+        this.add({
+            title,
+            timestamp: new Date().toISOString(),
+            severity: "critical",
+        });
+    }
+    warning(title) {
+        this.add({
+            title,
+            timestamp: new Date().toISOString(),
+            severity: "warning",
+        });
+    }
+    info(title) {
+        this.add({
+            title,
+            timestamp: new Date().toISOString(),
+            severity: "info",
+        });
+    }
+    get(count) {
+        return this.alerts
+            .values()
+            .sort((a, b) => SEVERITY_PRIORITY[b.severity] -
+            SEVERITY_PRIORITY[a.severity])
+            .slice(0, count === undefined ? undefined : count)
+            .map(alert => ({
+            title: alert.title,
+            timestamp: alert.timestamp,
+            severity: alert.severity,
+        }));
+    }
+    latest() {
+        const alert = this.alerts.latest();
+        if (!alert) {
+            return undefined;
+        }
+        return {
+            title: alert.title,
+            timestamp: alert.timestamp,
+            severity: alert.severity,
+        };
+    }
+    clear() {
+        this.alerts.clear();
+    }
+}
+exports.AlertStore = AlertStore;

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

@@ -0,0 +1,15 @@
+import type { AnalyticsData } from "../../domain";
+import { EndpointStore } from "./endpoint.store";
+import type { BucketStore } from "./bucket.store";
+declare class AnalyticsStore {
+    private readonly buckets;
+    private readonly endpoints;
+    private readonly slowLatencyThreshold;
+    constructor(buckets: BucketStore, endpoints: EndpointStore, slowLatencyThreshold?: number);
+    get(page?: number, pageSize?: number): AnalyticsData;
+    private calculateSummary;
+    private latencyDistribution;
+    private requestVolume;
+    private endpointName;
+}
+export { AnalyticsStore };

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsStore = void 0;
+const utility_1 = require("../../utility");
+class AnalyticsStore {
+    buckets;
+    endpoints;
+    slowLatencyThreshold;
+    constructor(buckets, endpoints, slowLatencyThreshold = 500) {
+        this.buckets = buckets;
+        this.endpoints = endpoints;
+        this.slowLatencyThreshold = slowLatencyThreshold;
+    }
+    get(page = 1, pageSize = 20) {
+        const history = this.buckets.getHistory();
+        const endpointList = this.endpoints.all();
+        const pagination = (0, utility_1.paginate)(endpointList, page, pageSize);
+        return {
+            summary: this.calculateSummary(endpointList),
+            latencyDistribution: this.latencyDistribution(endpointList),
+            requestVolume: this.requestVolume(endpointList),
+            endpointsTable: {
+                data: pagination.data,
+                pagination: pagination.meta,
+            },
+            history: history.map(bucket => bucket.endpoints),
+        };
+    }
+    calculateSummary(endpoints) {
+        return {
+            totalEndpoints: endpoints.length,
+            healthyEndpoints: endpoints.filter(e => e.errorRate === 0 && (e.p95 ?? 0) < this.slowLatencyThreshold).length,
+            slowEndpoints: endpoints.filter(e => (e.p95 ?? 0) >= this.slowLatencyThreshold).length,
+            slowEndpointsThreshold: this.slowLatencyThreshold,
+            errorEndpoints: endpoints.filter(e => e.errorRate > 0).length,
+        };
+    }
+    latencyDistribution(endpoints) {
+        return endpoints.map(endpoint => ({
+            endpoint: this.endpointName(endpoint),
+            p50: endpoint.averageLatency ?? 0,
+            p95: endpoint.p95 ?? 0,
+            p99: endpoint.p99 ?? 0,
+        }));
+    }
+    requestVolume(endpoints) {
+        return endpoints
+            .map(endpoint => ({
+            endpoint: this.endpointName(endpoint),
+            volume: endpoint.requestCount ?? 0,
+            rps: endpoint.rps,
+        }))
+            .sort((a, b) => b.volume - a.volume);
+    }
+    endpointName(endpoint) {
+        return `${endpoint.method} ${endpoint.route}`;
+    }
+}
+exports.AnalyticsStore = AnalyticsStore;

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

@@ -0,0 +1,40 @@
+import type { EndpointTelemetry } from '../../domain';
+import { HealthStore } from "../stores/health.store";
+import type { EndpointStore } from "../stores/endpoint.store";
+import type { MetricsStore } from "../stores/metrics.store";
+export interface TelemetryBucket {
+    timestamp: number;
+    rps: {
+        count: number;
+        perEndpoints: Map<string, number>;
+    };
+    latency: {
+        average: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    };
+    error: {
+        rate: number;
+        clientCount: number;
+        serverCount: number;
+    };
+    endpoints: EndpointTelemetry[];
+    health: ReturnType<HealthStore["get"]>;
+}
+export declare class BucketStore {
+    private readonly endpointStore;
+    private readonly healthStore;
+    private readonly metricsStore;
+    private readonly history;
+    private currentSecond;
+    private requestCount;
+    private endpointRequests;
+    constructor(endpointStore: EndpointStore, healthStore: HealthStore, metricsStore: MetricsStore, bufferSize?: number);
+    recordRequest(method: string, route: string): void;
+    flush(): void;
+    getHistory(): TelemetryBucket[];
+    latest(): TelemetryBucket | undefined;
+    private reset;
+    private getSecond;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketStore = void 0;
+const utility_1 = require("../utility");
+class BucketStore {
+    endpointStore;
+    healthStore;
+    metricsStore;
+    history;
+    currentSecond;
+    requestCount;
+    endpointRequests;
+    constructor(endpointStore, healthStore, metricsStore, bufferSize = 60) {
+        this.endpointStore = endpointStore;
+        this.healthStore = healthStore;
+        this.metricsStore = metricsStore;
+        this.history = new utility_1.RingBuffer(bufferSize);
+        this.currentSecond = this.getSecond();
+        this.requestCount = 0;
+        this.endpointRequests = new Map();
+    }
+    recordRequest(method, route) {
+        this.requestCount++;
+        const key = `${method}:${route}`;
+        const count = this.endpointRequests.get(key) ?? 0;
+        this.endpointRequests.set(key, count + 1);
+    }
+    flush() {
+        const now = this.getSecond();
+        // same second
+        if (now === this.currentSecond) {
+            return;
+        }
+        const endpoints = this.endpointStore.all();
+        const metrics = this.metricsStore.snapshot();
+        const bucket = {
+            timestamp: this.currentSecond,
+            rps: {
+                count: this.requestCount,
+                perEndpoints: new Map(this.endpointRequests),
+            },
+            latency: {
+                average: metrics.averageLatency,
+                p50: metrics.latency.p50,
+                p95: metrics.latency.p95,
+                p99: metrics.latency.p99,
+            },
+            error: {
+                rate: metrics.errorRate,
+                clientCount: metrics.errorClientCount,
+                serverCount: metrics.errorServerCount,
+            },
+            endpoints,
+            health: this.healthStore.get(),
+        };
+        this.history.push(bucket);
+        this.reset();
+        this.metricsStore.reset();
+        this.currentSecond = now;
+    }
+    getHistory() {
+        return this.history.values();
+    }
+    latest() {
+        return this.history.latest();
+    }
+    reset() {
+        this.requestCount = 0;
+        this.endpointRequests.clear();
+    }
+    getSecond() {
+        return (Math.floor(Date.now() / 1000) * 1000);
+    }
+}
+exports.BucketStore = BucketStore;

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

@@ -0,0 +1,15 @@
+import type { DashboardData } from '../../domain';
+import type { BucketStore } from './bucket.store';
+import type { HealthStore } from './health.store';
+import type { EndpointStore } from './endpoint.store';
+import type { AlertStore } from './alert.store';
+declare class DashboardStore {
+    private readonly buckets;
+    private readonly health;
+    private readonly endpoints;
+    private readonly alerts;
+    constructor(buckets: BucketStore, health: HealthStore, endpoints: EndpointStore, alerts: AlertStore);
+    get(): DashboardData;
+    private getImpactEndpoints;
+}
+export { DashboardStore };

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardStore = void 0;
+class DashboardStore {
+    buckets;
+    health;
+    endpoints;
+    alerts;
+    constructor(buckets, health, endpoints, alerts) {
+        this.buckets = buckets;
+        this.health = health;
+        this.endpoints = endpoints;
+        this.alerts = alerts;
+    }
+    get() {
+        const history = this.buckets.getHistory();
+        const latest = history[history.length - 1];
+        const health = this.health.get();
+        return {
+            current: {
+                rps: latest?.rps.count ?? 0,
+                latency: latest?.latency.average ?? 0,
+                errorRate: latest?.error.rate ?? 0,
+                eventLoopLag: health.eventLoop.lag,
+                heapUsage: health.memory.heapUsage,
+                heapSize: health.memory.heapSize
+            },
+            history: {
+                rps: history.map(bucket => bucket.rps.count),
+                latency: history.map(bucket => bucket.latency.average),
+                errorRate: history.map(bucket => bucket.error.rate),
+                eventLoopLag: history.map(bucket => bucket.health.eventLoop.lag),
+                heapUsage: history.map(bucket => bucket.health.memory.heapUsage),
+                heapSize: history.map(bucket => bucket.health.memory.heapSize),
+                rssMemory: history.map(bucket => bucket.health.memory.rssMemory),
+                totalHeap: history.map(bucket => bucket.health.memory.heapSize),
+                p95: history.map(bucket => bucket.latency.p95),
+                p99: history.map(bucket => bucket.latency.p99)
+            },
+            charts: {
+                throughput: {
+                    rps: history.map(bucket => bucket.rps.count),
+                    errorClient: history.map(bucket => bucket.error.clientCount),
+                    errorServer: history.map(bucket => bucket.error.serverCount),
+                    totalCount: history.reduce((acc, bucket) => acc + bucket.rps.count, 0)
+                },
+                percentiles: {
+                    p50: history.map(bucket => bucket.latency.p50),
+                    p95: history.map(bucket => bucket.latency.p95),
+                    p99: history.map(bucket => bucket.latency.p99),
+                    totalCount: history.reduce((acc, bucket) => acc + bucket.rps.count, 0)
+                },
+                runtimePerformance: {
+                    heapUsage: history.map(bucket => bucket.health.memory.heapUsage),
+                    heapSize: history.map(bucket => bucket.health.memory.heapSize),
+                    lag: history.map(bucket => bucket.health.eventLoop.lag),
+                    totalCount: history.reduce((acc, bucket) => acc + bucket.rps.count, 0)
+                }
+            },
+            impactEndpoints: this.getImpactEndpoints(),
+            alerts: this.alerts.get(5)
+        };
+    }
+    getImpactEndpoints() {
+        return this.endpoints
+            .all()
+            .filter(endpoint => {
+            return (endpoint.errorRate > 0 ||
+                endpoint.p95 > 500);
+        })
+            .sort((a, b) => {
+            const aScore = a.errorRate * 1000 + (a.p95 ?? 0);
+            const bScore = b.errorRate * 1000 + (b.p95 ?? 0);
+            return bScore - aScore;
+        }).slice(0, 10);
+    }
+}
+exports.DashboardStore = DashboardStore;