@serve.zone/dcrouter 18.9.3 → 18.9.4

package/dist_ts/monitoring/classes.metricscache.d.ts

@@ -1,34 +1,43 @@
+import * as plugins from '../plugins.js';
 export interface ICacheEntry<T> {
     data: T;
     timestamp: number;
     ttl: number;
 }
+export interface IMetricsCacheOptions {
+    maxAggregateEntries?: number;
+    maxSnapshotEntries?: number;
+    maxEstimatedBytes?: number;
+    maxInFlight?: number;
+}
+type TCacheCategory = 'aggregate' | 'snapshot';
+/** Uses the existing TypedRequest error envelope; polling callers retain their last result. */
+export declare class MetricsCapacityError extends plugins.typedrequest.TypedResponseError {
+    constructor();
+}
 export declare class MetricsCache {
-    private cache;
-    private inFlight;
     private readonly defaultTTL;
-    constructor(defaultTTL?: number);
-    /**
-     * Get cached data or compute and cache it
-     */
-    get<T>(key: string, computeFn: () => T | Promise<T>, ttl?: number): T | Promise<T>;
-    /**
-     * Invalidate a specific cache entry
-     */
+    private readonly caches;
+    private readonly inFlight;
+    private readonly admitted;
+    private readonly maxInFlight;
+    private readonly maxEstimatedBytes;
+    private stopped;
+    private generation;
+    private activeComputations;
+    constructor(defaultTTL?: number, options?: IMetricsCacheOptions);
+    private createCache;
+    get<T>(key: string, computeFn: () => T | Promise<T>, ttl?: number, category?: TCacheCategory): T | Promise<T>;
     invalidate(key: string): void;
-    /**
-     * Clear all cache entries
-     */
     clear(): void;
-    /**
-     * Get cache statistics
-     */
+    start(): void;
+    stop(): Promise<void>;
     getStats(): {
         size: number;
         keys: string[];
+        inFlight: number;
+        estimatedBytes: number;
     };
-    /**
-     * Clean up expired entries
-     */
     cleanup(): void;
 }
+export {};

package/dist_ts/monitoring/classes.metricscache.js

@@ -1,85 +1,156 @@
+import * as plugins from '../plugins.js';
+/** Uses the existing TypedRequest error envelope; polling callers retain their last result. */
+export class MetricsCapacityError extends plugins.typedrequest.TypedResponseError {
+    constructor() {
+        super('Metrics are busy; retry after 500 ms', { code: 'METRICS_CAPACITY', retryAfterMs: 500 });
+    }
+}
+/** Conservative retained-payload estimate, including Maps and shared object graphs. */
+function estimateBytes(value, budget, seen = new Set()) {
+    if (budget <= 0)
+        return 1;
+    if (typeof value === 'string')
+        return 24 + value.length * 2;
+    if (typeof value !== 'object' || value === null)
+        return 16;
+    if (seen.has(value))
+        return 8;
+    seen.add(value);
+    if (ArrayBuffer.isView(value))
+        return 64 + value.byteLength;
+    if (value instanceof ArrayBuffer)
+        return 64 + value.byteLength;
+    let size = 64;
+    if (value instanceof Map) {
+        for (const [key, entry] of value) {
+            size += 32 + estimateBytes(key, budget - size, seen) + estimateBytes(entry, budget - size, seen);
+            if (size > budget)
+                break;
+        }
+    }
+    else if (value instanceof Set) {
+        for (const entry of value) {
+            size += 16 + estimateBytes(entry, budget - size, seen);
+            if (size > budget)
+                break;
+        }
+    }
+    else {
+        for (const key of Object.keys(value)) {
+            size += 24 + key.length * 2 + estimateBytes(value[key], budget - size, seen);
+            if (size > budget)
+                break;
+        }
+    }
+    return size;
+}
 export class MetricsCache {
-    cache = new Map();
-    inFlight = new Map();
     defaultTTL;
-    constructor(defaultTTL = 500) {
+    caches;
+    inFlight = new Map();
+    admitted = new Set();
+    maxInFlight;
+    maxEstimatedBytes;
+    stopped = false;
+    generation = 0;
+    activeComputations = 0;
+    constructor(defaultTTL = 500, options = {}) {
         this.defaultTTL = defaultTTL;
+        this.maxInFlight = options.maxInFlight ?? 32;
+        this.maxEstimatedBytes = options.maxEstimatedBytes ?? 8 * 1024 * 1024;
+        this.caches = {
+            aggregate: this.createCache(options.maxAggregateEntries ?? 256),
+            snapshot: this.createCache(options.maxSnapshotEntries ?? 64),
+        };
+    }
+    createCache(max) {
+        return new plugins.lruCache.LRUCache({
+            max,
+            maxSize: this.maxEstimatedBytes,
+            // lru-cache owns bounded, unref'ed expiry timers, including idle keys.
+            ttlAutopurge: true,
+            ttlResolution: 0,
+            sizeCalculation: (entry, key) => 64 + key.length * 2 + estimateBytes(entry.data, this.maxEstimatedBytes),
+        });
     }
-    /**
-     * Get cached data or compute and cache it
-     */
-    get(key, computeFn, ttl) {
-        const cached = this.cache.get(key);
-        const now = Date.now();
-        const actualTTL = ttl ?? this.defaultTTL;
-        if (cached && (now - cached.timestamp) < cached.ttl) {
+    get(key, computeFn, ttl = this.defaultTTL, category = 'aggregate') {
+        if (this.stopped)
+            throw new Error('Metrics cache is stopped');
+        const cache = this.caches[category];
+        const cached = cache.get(key);
+        if (cached && Date.now() - cached.timestamp < cached.ttl)
             return cached.data;
-        }
-        if (cached) {
-            this.cache.delete(key);
-        }
-        const pending = this.inFlight.get(key);
-        if (pending) {
+        cache.delete(key);
+        const flightKey = JSON.stringify([category, key]);
+        const pending = this.inFlight.get(flightKey);
+        if (pending)
             return pending;
+        if (this.activeComputations >= this.maxInFlight)
+            throw new MetricsCapacityError();
+        const generation = this.generation;
+        this.activeComputations++;
+        let result;
+        try {
+            result = computeFn();
         }
-        const result = computeFn();
-        // Handle both sync and async compute functions
-        if (result instanceof Promise) {
-            let inFlightPromise;
-            inFlightPromise = result.then((data) => {
-                if (this.inFlight.get(key) === inFlightPromise) {
-                    this.inFlight.delete(key);
-                    this.cache.set(key, { data, timestamp: Date.now(), ttl: actualTTL });
-                }
-                return data;
-            }, (error) => {
-                if (this.inFlight.get(key) === inFlightPromise) {
-                    this.inFlight.delete(key);
-                    this.cache.delete(key);
-                }
-                throw error;
-            });
-            this.inFlight.set(key, inFlightPromise);
-            return inFlightPromise;
+        catch (error) {
+            this.activeComputations--;
+            throw error;
         }
-        else {
-            this.cache.set(key, { data: result, timestamp: now, ttl: actualTTL });
+        const remember = (data) => {
+            if (!this.stopped && generation === this.generation && ttl > 0) {
+                cache.set(key, { data, timestamp: Date.now(), ttl }, { ttl });
+            }
+        };
+        if (!(result instanceof Promise)) {
+            this.activeComputations--;
+            remember(result);
             return result;
         }
+        const run = result.then((data) => {
+            if (this.inFlight.get(flightKey) === run)
+                remember(data);
+            return data;
+        }).finally(() => {
+            this.activeComputations--;
+            this.admitted.delete(run);
+            if (this.inFlight.get(flightKey) === run)
+                this.inFlight.delete(flightKey);
+        });
+        this.admitted.add(run);
+        this.inFlight.set(flightKey, run);
+        return run;
     }
-    /**
-     * Invalidate a specific cache entry
-     */
     invalidate(key) {
-        this.cache.delete(key);
-        this.inFlight.delete(key);
+        for (const category of ['aggregate', 'snapshot']) {
+            this.caches[category].delete(key);
+            this.inFlight.delete(JSON.stringify([category, key]));
+        }
     }
-    /**
-     * Clear all cache entries
-     */
     clear() {
-        this.cache.clear();
+        this.generation++;
+        this.caches.aggregate.clear();
+        this.caches.snapshot.clear();
         this.inFlight.clear();
+        // Invalidated work retains its admission slot until it actually settles.
+    }
+    start() { this.stopped = false; }
+    async stop() {
+        this.stopped = true;
+        this.clear();
+        await Promise.allSettled(this.admitted);
     }
-    /**
-     * Get cache statistics
-     */
     getStats() {
         return {
-            size: this.cache.size,
-            keys: Array.from(this.cache.keys())
+            size: this.caches.aggregate.size + this.caches.snapshot.size,
+            keys: [...this.caches.aggregate.keys(), ...this.caches.snapshot.keys()],
+            inFlight: this.activeComputations,
+            estimatedBytes: this.caches.aggregate.calculatedSize + this.caches.snapshot.calculatedSize,
         };
     }
-    /**
-     * Clean up expired entries
-     */
     cleanup() {
-        const now = Date.now();
-        for (const [key, entry] of this.cache.entries()) {
-            if (now - entry.timestamp > entry.ttl) {
-                this.cache.delete(key);
-            }
-        }
+        this.caches.aggregate.purgeStale();
+        this.caches.snapshot.purgeStale();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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