apm-optima 1.0.4 → 2.0.0

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

@@ -1,78 +1,210 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DashboardStore = void 0;
+const bucket_metric_1 = require("./bucket-metric");
+const DASHBOARD_HISTORY_LENGTH = 60;
+const MAX_IMPACT_ENDPOINTS = 10;
+const MAX_ALERTS = 5;
+const IMPACT_P95_THRESHOLD_MS = 500;
 class DashboardStore {
     buckets;
     health;
-    endpoints;
     alerts;
-    constructor(buckets, health, endpoints, alerts) {
+    constructor(buckets, health, 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,
+    metrics(bucket) {
+        return (0, bucket_metric_1.deriveMetrics)(bucket.requests, bucket.durationMs);
+    }
+    buildCurrent(latest, health) {
+        if (!latest) {
+            return {
+                rps: 0,
+                latency: 0,
+                errorRate: 0,
                 eventLoopLag: health.eventLoop.lag,
                 heapUsage: health.memory.heapUsage,
                 heapSize: health.memory.heapSize
+            };
+        }
+        const metrics = this.metrics(latest);
+        return {
+            rps: Math.round(metrics.rps),
+            latency: metrics.averageLatency,
+            errorRate: metrics.errorRate,
+            eventLoopLag: health.eventLoop.lag,
+            heapUsage: health.memory.heapUsage,
+            heapSize: health.memory.heapSize
+        };
+    }
+    buildHistory(history) {
+        return {
+            rps: this.fillRest(history.map(bucket => Math.round(this.metrics(bucket).rps)), DASHBOARD_HISTORY_LENGTH, 0),
+            latency: this.fillRest(history.map(bucket => this.metrics(bucket).averageLatency), DASHBOARD_HISTORY_LENGTH, 0),
+            errorRate: this.fillRest(history.map(bucket => this.metrics(bucket).errorRate), DASHBOARD_HISTORY_LENGTH, 0),
+            eventLoopLag: this.fillRest(history.map(() => this.health.get().eventLoop.lag), DASHBOARD_HISTORY_LENGTH, 0),
+            heapUsage: this.fillRest(history.map(() => this.health.get().memory.heapUsage), DASHBOARD_HISTORY_LENGTH, 0),
+            heapSize: this.fillRest(history.map(() => this.health.get().memory.heapSize), DASHBOARD_HISTORY_LENGTH, 0),
+            rssMemory: this.fillRest(history.map(() => this.health.get().memory.rssMemory), DASHBOARD_HISTORY_LENGTH, 0),
+            totalHeap: this.fillRest(history.map(() => this.health.get().memory.heapSize), DASHBOARD_HISTORY_LENGTH, 0),
+            p95: this.fillRest(history.map(bucket => this.metrics(bucket).p95), DASHBOARD_HISTORY_LENGTH, 0),
+            p99: this.fillRest(history.map(bucket => this.metrics(bucket).p99), DASHBOARD_HISTORY_LENGTH, 0),
+        };
+    }
+    buildHistoryTick(latest) {
+        if (!latest) {
+            return {
+                rps: 0,
+                latency: 0,
+                errorRate: 0,
+                eventLoopLag: this.health.get().eventLoop.lag,
+                heapUsage: this.health.get().memory.heapUsage,
+                heapSize: this.health.get().memory.heapSize,
+                rssMemory: this.health.get().memory.rssMemory,
+                totalHeap: this.health.get().memory.heapSize
+            };
+        }
+        const metrics = this.metrics(latest);
+        return {
+            rps: metrics.rps,
+            latency: metrics.averageLatency,
+            errorRate: metrics.errorRate,
+            eventLoopLag: this.health.get().eventLoop.lag,
+            heapUsage: this.health.get().memory.heapUsage,
+            heapSize: this.health.get().memory.heapSize,
+            rssMemory: this.health.get().memory.rssMemory,
+            totalHeap: this.health.get().memory.heapSize
+        };
+    }
+    //! FIX RUNTIME MISSING FROM BUCKETS
+    buildCharts(history) {
+        const metrics = history.map(bucket => this.metrics(bucket));
+        return {
+            throughput: {
+                rps: this.fillRest(metrics.map(value => value.rps), DASHBOARD_HISTORY_LENGTH, 0),
+                errorClient: this.fillRest(metrics.map(value => value.clientErrorCount), DASHBOARD_HISTORY_LENGTH, 0),
+                errorServer: this.fillRest(metrics.map(value => value.serverErrorCount), DASHBOARD_HISTORY_LENGTH, 0),
+                totalCount: this.getTotalRequestCount(history)
             },
-            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)
+            percentiles: {
+                p50: this.fillRest(metrics.map(value => value.p50), DASHBOARD_HISTORY_LENGTH, 0),
+                p95: this.fillRest(metrics.map(value => value.p95), DASHBOARD_HISTORY_LENGTH, 0),
+                p99: this.fillRest(metrics.map(value => value.p99), DASHBOARD_HISTORY_LENGTH, 0),
+                totalCount: this.getTotalRequestCount(history)
             },
-            charts: {
+            runtimePerformance: {
+                heapUsage: this.fillRest(metrics.map(value => this.health.get().memory.heapUsage), DASHBOARD_HISTORY_LENGTH, 0),
+                heapSize: this.fillRest(metrics.map(value => this.health.get().memory.heapSize), DASHBOARD_HISTORY_LENGTH, 0),
+                lag: this.fillRest(metrics.map(value => this.health.get().eventLoop.lag), DASHBOARD_HISTORY_LENGTH, 0),
+                totalCount: this.getTotalRequestCount(history)
+            }
+        };
+    }
+    buildChartsTick(latest) {
+        if (!latest) {
+            return {
                 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)
+                    rps: 0,
+                    errorClient: 0,
+                    errorServer: 0,
+                    totalCount: 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)
+                    p50: 0,
+                    p95: 0,
+                    p99: 0,
+                    totalCount: 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)
+                    heapUsage: this.health.get().memory.heapUsage,
+                    heapSize: this.health.get().memory.heapSize,
+                    lag: this.health.get().eventLoop.lag,
+                    totalCount: 0
                 }
+            };
+        }
+        const metrics = this.metrics(latest);
+        return {
+            throughput: {
+                rps: metrics.rps,
+                errorClient: metrics.clientErrorCount,
+                errorServer: metrics.serverErrorCount,
+                totalCount: metrics.requestCount
             },
+            percentiles: {
+                p50: metrics.p50,
+                p95: metrics.p95,
+                p99: metrics.p99,
+                totalCount: metrics.requestCount
+            },
+            runtimePerformance: {
+                heapUsage: this.health.get().memory.heapUsage,
+                heapSize: this.health.get().memory.heapSize,
+                lag: this.health.get().eventLoop.lag,
+                totalCount: metrics.requestCount
+            }
+        };
+    }
+    get() {
+        const history = this.buckets.getHistory();
+        const latest = this.buckets.latest();
+        const health = this.health.get();
+        return {
+            current: this.buildCurrent(latest, health),
+            history: this.buildHistory(history),
+            charts: this.buildCharts(history),
+            impactEndpoints: this.getImpactEndpoints(),
+            alerts: this.alerts.get(MAX_ALERTS)
+        };
+    }
+    getTickData() {
+        const latest = this.buckets.latest();
+        const health = this.health.get();
+        return {
+            current: this.buildCurrent(latest, health),
+            history: this.buildHistoryTick(latest),
+            charts: this.buildChartsTick(latest),
             impactEndpoints: this.getImpactEndpoints(),
-            alerts: this.alerts.get(5)
+            alerts: this.alerts.get(MAX_ALERTS)
         };
     }
+    fillRest(values, length, fillValue) {
+        const filledValues = [...values];
+        while (filledValues.length < length) {
+            filledValues.unshift(fillValue);
+        }
+        return filledValues;
+    }
+    getTotalRequestCount(history) {
+        return history.reduce((acc, bucket) => acc + bucket.requests.requestCount, 0);
+    }
     getImpactEndpoints() {
-        return this.endpoints
-            .all()
-            .filter(endpoint => {
-            return (endpoint.errorRate > 0 ||
-                endpoint.p95 > 500);
+        const latest = this.buckets.latest();
+        if (!latest)
+            return [];
+        return latest.endpoints
+            .map(endpoint => {
+            const metrics = (0, bucket_metric_1.deriveMetrics)(endpoint, latest.durationMs);
+            return {
+                method: endpoint.method,
+                route: endpoint.route,
+                rps: metrics.rps,
+                requestCount: metrics.requestCount,
+                averageLatency: metrics.averageLatency,
+                minLatency: metrics.minLatency,
+                p95: metrics.p95,
+                p99: metrics.p99,
+                errorRate: metrics.errorRate,
+                status: metrics.errorRate > 0 ? 'DEGRADED' : 'HEALTHY',
+            };
         })
-            .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);
+            .filter(endpoint => endpoint.errorRate > 0 ||
+            endpoint.p95 > IMPACT_P95_THRESHOLD_MS)
+            .sort((a, b) => (b.errorRate * 1000 + b.p95) -
+            (a.errorRate * 1000 + a.p95))
+            .slice(0, MAX_IMPACT_ENDPOINTS);
     }
 }
 exports.DashboardStore = DashboardStore;

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

@@ -11,6 +11,7 @@ declare class EndpointStore {
     get(method: string, route: string): EndpointTelemetry | undefined;
     all(): EndpointTelemetry[];
     private map;
+    private handleTrackingRecord;
     reset(): void;
 }
 export { EndpointStore };

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

@@ -17,44 +17,60 @@ class EndpointStore {
                 requestCount: 0,
                 errorCount: 0,
                 totalLatency: 0,
+                minLatency: input.duration,
                 histogram: new utility_1.Histogram(),
                 lastRequestAt: Date.now(),
+                rps: 0,
+                lastCalculationRequestCount: 0,
+                lastRecalculatedAt: 0,
             };
             this.endpoints.set(key, endpoint);
         }
         endpoint.requestCount++;
         endpoint.totalLatency += input.duration;
+        endpoint.minLatency = Math.min(endpoint.minLatency, input.duration);
         endpoint.lastRequestAt = Date.now();
         endpoint.histogram.record(input.duration);
         if (input.statusCode >= 400) {
             endpoint.errorCount++;
         }
+        this.handleTrackingRecord(endpoint, Date.now());
     }
     get(method, route) {
         const endpoint = this.endpoints.get(this.createKey(method, route));
         if (!endpoint) {
             return undefined;
         }
-        return this.map(endpoint);
+        return this.map(endpoint, Date.now());
     }
     all() {
-        return [...this.endpoints.values()].map(endpoint => this.map(endpoint));
+        const now = Date.now();
+        return [...this.endpoints.values()].map(endpoint => this.map(endpoint, now));
     }
-    map(endpoint) {
+    map(endpoint, now) {
         const histogram = endpoint.histogram.snapshot();
+        this.handleTrackingRecord(endpoint, now);
         return {
             method: endpoint.method,
             route: endpoint.route,
-            rps: endpoint.requestCount - histogram.count, //????
-            // calculated later from buckets
+            rps: endpoint.rps,
             requestCount: endpoint.requestCount,
             averageLatency: endpoint.requestCount === 0 ? 0 : endpoint.totalLatency / endpoint.requestCount,
+            minLatency: endpoint.minLatency,
             p95: histogram.p95,
             p99: histogram.p99,
             errorRate: endpoint.requestCount === 0 ? 0 : endpoint.errorCount / endpoint.requestCount,
             status: endpoint.errorCount > 0 ? "DEGRADED" : "HEALTHY",
         };
     }
+    handleTrackingRecord(endpoint, now) {
+        if (now - endpoint.lastRecalculatedAt >= 1000) {
+            const requestsSinceLastCalculation = endpoint.requestCount - endpoint.lastCalculationRequestCount;
+            endpoint.rps = requestsSinceLastCalculation;
+            endpoint.lastCalculationRequestCount = endpoint.requestCount;
+            endpoint.lastRecalculatedAt = now;
+        }
+    }
     reset() {
         this.endpoints.clear();
     }

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

@@ -1,8 +1 @@
-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

@@ -14,11 +14,4 @@ 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

@@ -17,7 +17,7 @@ export declare class MetricsStore {
     record(input: {
         duration: number;
         statusCode: number;
-    }): "SUCCESS" | "FAILED" | "ANOMALY";
+    }): "ANOMALY" | "SUCCESS" | "FAILED";
     snapshot(): MetricsSnapshot;
     reset(): void;
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricsStore = void 0;
 const utility_1 = require("../utility");
+//! This is done
 class MetricsStore {
     requestCount;
     errorClientCount;

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

@@ -0,0 +1,77 @@
+import type { RuntimeInterval } from './bucket-metric';
+import type { ReadonlyConfig } from '../../../config';
+export interface RuntimeDetails {
+    numberOfCores: number;
+    perCoreUsage: number[];
+    rssMemoryTotal: number;
+    externalMemory: number;
+    arrayBuffers: number;
+    gc: {
+        gcCount: number;
+        gcTime: number;
+        minorGC: {
+            runCount: number;
+            averageTime: number;
+        };
+        majorGC: {
+            runCount: number;
+            averageTime: number;
+        };
+        incrementalGC: {
+            runCount: number;
+            averageTime: number;
+        };
+        heapSpaces: {
+            label: string;
+            used: number;
+        }[];
+        gcTotals: {
+            totalPauseTime: number;
+            freedMemory: number;
+            promotions: number;
+            tenuredSize: number;
+        };
+    };
+    handles: {
+        activeHandles: number;
+        activeHandlesTimers: number;
+        activeHandlesSockets: number;
+        activeLibuvHandles: number;
+        timers: number;
+        fileDescriptors: number;
+    };
+    runtime: {
+        pid: number;
+        platform: NodeJS.Platform;
+        nodeVersion: string;
+        v8Version: string;
+        libuvVersion: string;
+        openSSLVersion: string;
+        threadPoolSize: number;
+        activeThreads: number;
+        startup: {
+            bootstrapTime: number;
+            requiredModules: number;
+        };
+    };
+}
+export declare class RuntimeStore {
+    readonly config: ReadonlyConfig;
+    private readonly loopDelay;
+    private gcObserver;
+    private disposed;
+    private lastCpu;
+    private intervalGcCount;
+    private intervalGcDurationMs;
+    private readonly gcTotals;
+    private lastCoreTimes;
+    constructor(config: ReadonlyConfig);
+    private recordGC;
+    closeInterval(): RuntimeInterval;
+    private collectPerCore;
+    private collectGCDetails;
+    private collectHandles;
+    private collectRuntime;
+    details(): RuntimeDetails;
+    dispose(): void;
+}

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

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeStore = void 0;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const v8_1 = __importDefault(require("v8"));
+const node_os_1 = __importDefault(require("node:os"));
+const utility_1 = require("../../utility");
+class RuntimeStore {
+    config;
+    loopDelay;
+    gcObserver = null;
+    disposed = false;
+    lastCpu = process.cpuUsage();
+    intervalGcCount = 0;
+    intervalGcDurationMs = 0;
+    gcTotals = {
+        gcCount: 0,
+        gcTime: 0,
+        minorGC: { runCount: 0, totalTime: 0 },
+        majorGC: { runCount: 0, totalTime: 0 },
+        incrementalGC: { runCount: 0, totalTime: 0 },
+        freedMemory: 0
+    };
+    lastCoreTimes = node_os_1.default.cpus().map(c => ({ ...c.times }));
+    constructor(config) {
+        this.config = config;
+        this.loopDelay = (0, node_perf_hooks_1.monitorEventLoopDelay)({ resolution: config.collection.eventLoopResolutionMs });
+        this.loopDelay.enable();
+        try {
+            this.gcObserver = new node_perf_hooks_1.PerformanceObserver(list => {
+                for (const e of list.getEntries())
+                    this.recordGC(e);
+            });
+            this.gcObserver.observe({ entryTypes: ['gc'] });
+        }
+        catch {
+            this.gcObserver = null;
+        }
+    }
+    recordGC(e) {
+        this.intervalGcCount++;
+        this.intervalGcDurationMs += e.duration;
+        this.gcTotals.gcCount++;
+        this.gcTotals.gcTime += e.duration;
+        const detail = e.detail;
+        const kind = detail ? detail.kind : 0;
+        const bucket = kind === 1 ? this.gcTotals.minorGC
+            : kind === 2 ? this.gcTotals.majorGC
+                : this.gcTotals.incrementalGC;
+        bucket.runCount++;
+        bucket.totalTime += e.duration;
+        if (detail?.freedMemory)
+            this.gcTotals.freedMemory += detail.freedMemory;
+    }
+    closeInterval() {
+        let cpuUserUs = null;
+        let cpuSystemUs = null;
+        try {
+            const now = process.cpuUsage();
+            cpuUserUs = now.user - this.lastCpu.user;
+            cpuSystemUs = now.system - this.lastCpu.system;
+            this.lastCpu = now;
+        }
+        catch { }
+        let heapUsedBytes = null;
+        let heapTotalBytes = null;
+        let heapLimitBytes = null;
+        let rssBytes = null;
+        try {
+            const memory = process.memoryUsage();
+            heapUsedBytes = memory.heapUsed;
+            heapTotalBytes = memory.heapTotal;
+            rssBytes = memory.rss;
+            heapLimitBytes = v8_1.default.getHeapStatistics().heap_size_limit;
+        }
+        catch { }
+        let eventLoopSampleCount = 0;
+        let eventLoopDelaySumMs = null;
+        let eventLoopDelayMaxMs = null;
+        if (!this.disposed) {
+            try {
+                eventLoopSampleCount = this.loopDelay.count;
+                if (eventLoopSampleCount > 0) {
+                    eventLoopDelaySumMs = (this.loopDelay.mean * eventLoopSampleCount) / 1e6;
+                    eventLoopDelayMaxMs = this.loopDelay.max / 1e6;
+                }
+            }
+            catch {
+                eventLoopSampleCount = 0;
+            }
+            this.loopDelay.reset();
+        }
+        const gcCount = this.gcObserver ? this.intervalGcCount : null;
+        const gcDurationSumMs = this.gcObserver ? this.intervalGcDurationMs : null;
+        this.intervalGcCount = 0;
+        this.intervalGcDurationMs = 0;
+        return {
+            cpuTimeUs: cpuUserUs !== null && cpuSystemUs !== null ? cpuUserUs + cpuSystemUs : null,
+            cpuUserUs,
+            cpuSystemUs,
+            heapUsedBytes,
+            heapTotalBytes,
+            heapLimitBytes,
+            rssBytes,
+            eventLoopSampleCount,
+            eventLoopDelaySumMs,
+            eventLoopDelayMaxMs,
+            gcCount,
+            gcDurationSumMs,
+        };
+    }
+    collectPerCore() {
+        try {
+            const cpus = node_os_1.default.cpus();
+            const perCoreUsage = cpus.map((core, i) => {
+                const prev = this.lastCoreTimes[i];
+                const cur = core.times;
+                const total = (t) => t.user + t.nice + t.sys + t.idle + t.irq;
+                const dTotal = prev ? total(cur) - total(prev) : total(cur);
+                const dIdle = prev ? cur.idle - prev.idle : cur.idle;
+                return dTotal > 0 ? (0, utility_1.toPercentage)(dTotal - dIdle, dTotal) : 0;
+            });
+            this.lastCoreTimes = cpus.map(c => ({ ...c.times }));
+            return { numberOfCores: cpus.length, perCoreUsage };
+        }
+        catch {
+            return { numberOfCores: 0, perCoreUsage: [] };
+        }
+    }
+    collectGCDetails() {
+        const t = this.gcTotals;
+        const avg = (k) => k.runCount > 0 ? parseFloat((k.totalTime / k.runCount).toFixed(2)) : 0;
+        let heapSpaces = [];
+        let tenuredSize = 0;
+        try {
+            const spaceStats = v8_1.default.getHeapSpaceStatistics();
+            heapSpaces = spaceStats.map(space => ({ label: space.space_name, used: space.space_used_size / 1024 / 1024 }));
+            const old = spaceStats.find(s => s.space_name === 'old_space');
+            tenuredSize = old ? old.space_used_size / 1024 / 1024 : 0;
+        }
+        catch { }
+        return {
+            gcCount: t.gcCount,
+            gcTime: parseFloat(t.gcTime.toFixed(2)),
+            minorGC: { runCount: t.minorGC.runCount, averageTime: avg(t.minorGC) },
+            majorGC: { runCount: t.majorGC.runCount, averageTime: avg(t.majorGC) },
+            incrementalGC: { runCount: t.incrementalGC.runCount, averageTime: avg(t.incrementalGC) },
+            heapSpaces,
+            gcTotals: {
+                totalPauseTime: parseFloat(t.gcTime.toFixed(2)),
+                freedMemory: (0, utility_1.convertBytes)(t.freedMemory, 'MB'),
+                promotions: t.majorGC.runCount,
+                tenuredSize
+            }
+        };
+    }
+    collectHandles() {
+        const handles = process._getActiveHandles ? process._getActiveHandles() : [];
+        let timers = 0;
+        let sockets = 0;
+        for (const h of handles) {
+            if (h.constructor && h.constructor.name === 'Timeout')
+                timers++;
+            if (h.constructor && (h.constructor.name === 'Socket' || h.constructor.name === 'TCPSocket'))
+                sockets++;
+        }
+        return {
+            activeHandles: handles.length,
+            activeHandlesTimers: timers,
+            activeHandlesSockets: sockets,
+            activeLibuvHandles: handles.length,
+            timers,
+            fileDescriptors: handles.length
+        };
+    }
+    collectRuntime() {
+        const threadPoolSize = process.env.UV_THREADPOOL_SIZE ? parseInt(process.env.UV_THREADPOOL_SIZE) : 4;
+        const activeThreads = process._getActiveRequests?.().length ?? 0;
+        return {
+            pid: process.pid,
+            platform: process.platform,
+            nodeVersion: process.version,
+            v8Version: process.versions.v8,
+            libuvVersion: process.versions.uv,
+            openSSLVersion: process.versions.openssl,
+            threadPoolSize: threadPoolSize,
+            activeThreads: activeThreads,
+            startup: {
+                bootstrapTime: performance.now(),
+                requiredModules: Object.keys(require.cache).length,
+            }
+        };
+    }
+    details() {
+        let memory;
+        try {
+            const m = process.memoryUsage();
+            memory = { rssMemoryTotal: node_os_1.default.totalmem(), externalMemory: m.external, arrayBuffers: m.arrayBuffers };
+        }
+        catch {
+            memory = { rssMemoryTotal: 0, externalMemory: 0, arrayBuffers: 0 };
+        }
+        return {
+            ...this.collectPerCore(),
+            ...memory,
+            gc: this.collectGCDetails(),
+            handles: this.collectHandles(),
+            runtime: this.collectRuntime(),
+        };
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.loopDelay.disable();
+        this.gcObserver?.disconnect();
+    }
+}
+exports.RuntimeStore = RuntimeStore;

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

@@ -0,0 +1 @@
+export declare function tryOrDefault<T>(fn: () => Promise<T>, fallback: T): Promise<T>;