badmfck-api-server 4.1.59 → 5.0.2

package/dist/apiServer/APIService.d.ts

@@ -51,6 +51,7 @@ export interface APIServiceOptions<TInterceptor = unknown> {
     appVersion?: string;
     fileTempDir: string;
     fileLimit: number;
+    metricsDir?: string;
 }
 type InferInterceptor<T> = T extends IInterceptor<infer U> ? U : unknown;
 export declare const getDefaultOptions: <I extends IInterceptor<any> | undefined>(overrides?: Omit<Partial<APIServiceOptions<InferInterceptor<NonNullable<I>>>>, "interceptor"> & {

package/dist/apiServer/APIService.js

@@ -79,6 +79,7 @@ function defaultOptions() {
             documentation: []
         },
         appVersion: undefined,
+        metricsDir: undefined,
         fileTempDir: "/tmp",
         fileLimit: 10_000_000,
         keepAliveTimeout: 25 * 1000,
@@ -165,7 +166,7 @@ class APIService extends BaseService_1.BaseService {
                 new Monitor_1.Monitor(this.options),
             ];
         }
-        this.monitor = new MonitorService_1.MonitorService();
+        this.monitor = new MonitorService_1.MonitorService(this.options.metricsDir);
         this.monitor.init();
         new DocumentService_1.DocumentGenerator(this.options.endpoints);
         this.options.endpoints.push(new Liveness_1.Liveness(this.started), new Readiness_1.Readiness(this.started));

package/dist/apiServer/MonitorService.d.ts

@@ -15,6 +15,11 @@ export declare const S_STAT_REGISTRATE_SERVICE: Signal<string>;
 export declare const S_STAT_REGISTRATE_HTTP_REQUEST: Signal<{
     url: string;
 }>;
+export declare const S_STAT_REGISTRATE_HTTP_RESULT: Signal<{
+    host: string;
+    ok: boolean;
+    ms: number;
+}>;
 export declare const S_STAT_REGISTRATE_SQL_REQUEST: Signal<{
     success: boolean;
     query: string;
@@ -22,6 +27,10 @@ export declare const S_STAT_REGISTRATE_SQL_REQUEST: Signal<{
 export declare const REQ_STAT: Req<{
     range: "week" | "day" | "hour";
 }, IStat[]>;
+export declare const REQ_STAT_WEEKS: Req<void, string[]>;
+export declare const REQ_STAT_WEEK: Req<{
+    weekKey: string;
+}, IStat[]>;
 type IMonitorSlot = {
     yyyymmddhhii: number;
     cpu: number;
@@ -35,6 +44,9 @@ type IMonitorSlot = {
     successEp: Record<string, number>;
     failEp: Record<string, number>;
     http: Record<string, number>;
+    http_ok: Record<string, number>;
+    http_fail: Record<string, number>;
+    httpP95: Record<string, number>;
     success_sql: Record<string, number>;
     fail_sql: Record<string, number>;
 };
@@ -43,8 +55,15 @@ export declare class MonitorService extends BaseService {
     intervalMs: number;
     lastCpuUsage: NodeJS.CpuUsage | null;
     lastTimestamp: number | null;
-    constructor();
+    private metricsDir;
+    private static MAX_WEEKS;
+    private static SCHEMA_VERSION;
+    private _persistReady;
+    private _flushedUpTo;
+    private _lastSeenWeekKey;
+    constructor(metricsDir?: string | null);
     init(): Promise<void>;
+    finishService(): Promise<void>;
     getEPStat(req: {
         range: "week" | "day" | "hour";
     }): Promise<IStat[]>;
@@ -57,7 +76,24 @@ export declare class MonitorService extends BaseService {
     static normalizeUrl(url: string): string;
     private bumpCappedKey;
     private onHttpRequestRegistrate;
+    private _latByMinute;
+    private static LAT_CAP_PER_MIN;
+    private onHttpResultRegistrate;
+    private finalizeLatency;
     private onSQLRequestRegistrate;
     private getSlot;
+    private liveFile;
+    private archiveFile;
+    private weekKey;
+    private atomicWrite;
+    private normalizeSlot;
+    private readJsonl;
+    private persistTick;
+    private rotate;
+    private downsampleWeek;
+    private mergeSlots;
+    private hydrate;
+    private listPersistedWeeks;
+    private readPersistedWeek;
 }
 export {};

package/dist/apiServer/MonitorService.js

@@ -36,32 +36,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonitorService = exports.REQ_STAT = exports.S_STAT_REGISTRATE_SQL_REQUEST = exports.S_STAT_REGISTRATE_HTTP_REQUEST = exports.S_STAT_REGISTRATE_SERVICE = exports.S_STAT_REGISTRATE_CUSTOM_EVENT = exports.S_STAT_REGISTRATE_REQUEST = void 0;
+exports.MonitorService = exports.REQ_STAT_WEEK = exports.REQ_STAT_WEEKS = exports.REQ_STAT = exports.S_STAT_REGISTRATE_SQL_REQUEST = exports.S_STAT_REGISTRATE_HTTP_RESULT = exports.S_STAT_REGISTRATE_HTTP_REQUEST = exports.S_STAT_REGISTRATE_SERVICE = exports.S_STAT_REGISTRATE_CUSTOM_EVENT = exports.S_STAT_REGISTRATE_REQUEST = void 0;
 const badmfck_signal_1 = __importStar(require("badmfck-signal"));
 const BaseService_1 = require("./BaseService");
 const YYYYMMDDHH_1 = require("./helper/YYYYMMDDHH");
+const LogService_1 = require("./LogService");
 const os_1 = __importDefault(require("os"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 exports.S_STAT_REGISTRATE_REQUEST = new badmfck_signal_1.default();
 exports.S_STAT_REGISTRATE_CUSTOM_EVENT = new badmfck_signal_1.default();
 exports.S_STAT_REGISTRATE_SERVICE = new badmfck_signal_1.default();
 exports.S_STAT_REGISTRATE_HTTP_REQUEST = new badmfck_signal_1.default();
+exports.S_STAT_REGISTRATE_HTTP_RESULT = new badmfck_signal_1.default();
 exports.S_STAT_REGISTRATE_SQL_REQUEST = new badmfck_signal_1.default();
 exports.REQ_STAT = new badmfck_signal_1.Req(undefined, "REQ_STAT");
+exports.REQ_STAT_WEEKS = new badmfck_signal_1.Req(undefined, "REQ_STAT_WEEKS");
+exports.REQ_STAT_WEEK = new badmfck_signal_1.Req(undefined, "REQ_STAT_WEEK");
 class MonitorService extends BaseService_1.BaseService {
     slots = new Map();
     intervalMs = 59_000;
     lastCpuUsage = null;
     lastTimestamp = null;
-    constructor() {
+    metricsDir;
+    static MAX_WEEKS = 10;
+    static SCHEMA_VERSION = 2;
+    _persistReady = false;
+    _flushedUpTo = 0;
+    _lastSeenWeekKey = null;
+    constructor(metricsDir) {
         super("MonitorService");
+        this.metricsDir = metricsDir && metricsDir.length > 0 ? metricsDir : null;
         setInterval(() => this.collectUsage(), this.intervalMs);
     }
     async init() {
         super.init();
         exports.REQ_STAT.listener = async (req) => this.getEPStat(req);
+        exports.REQ_STAT_WEEKS.listener = async () => this.listPersistedWeeks();
+        exports.REQ_STAT_WEEK.listener = async (req) => this.readPersistedWeek(req.weekKey);
         exports.S_STAT_REGISTRATE_HTTP_REQUEST.subscribe((data) => this.onHttpRequestRegistrate(data));
+        exports.S_STAT_REGISTRATE_HTTP_RESULT.subscribe((data) => this.onHttpResultRegistrate(data));
         exports.S_STAT_REGISTRATE_SQL_REQUEST.subscribe((data) => this.onSQLRequestRegistrate(data));
         exports.S_STAT_REGISTRATE_REQUEST.subscribe((data) => this.onStatRegistrate(data));
+        if (this.metricsDir) {
+            try {
+                await promises_1.default.mkdir(this.metricsDir, { recursive: true });
+            }
+            catch (e) {
+                (0, LogService_1.logWarn)("metrics: cannot create metricsDir, disk persistence disabled: " + (e?.message ?? e));
+                this.metricsDir = null;
+            }
+        }
+        if (this.metricsDir) {
+            await this.hydrate();
+            await this.rotate();
+            this._lastSeenWeekKey = this.weekKey(new Date());
+            this._persistReady = true;
+        }
+    }
+    async finishService() {
+        await super.finishService();
+        if (this.metricsDir && this._persistReady)
+            await this.persistTick(true).catch(() => { });
     }
     async getEPStat(req) {
         const allSlots = [];
@@ -91,33 +127,45 @@ class MonitorService extends BaseService_1.BaseService {
                 successEp: {},
                 failEp: {},
                 http: {},
+                http_ok: {},
+                http_fail: {},
+                httpP95: {},
                 success_sql: {},
                 fail_sql: {}
             };
+            const sum = (dst, src) => {
+                if (!src)
+                    return;
+                for (const [k, v] of Object.entries(src))
+                    dst[k] = (dst[k] || 0) + v;
+            };
+            const maxInto = (dst, src) => {
+                if (!src)
+                    return;
+                for (const [k, v] of Object.entries(src))
+                    dst[k] = Math.max(dst[k] || 0, v);
+            };
             chunk.forEach(s => {
                 agg.cpu += s.cpu;
                 agg.memory.rss += s.memory.rss;
                 agg.memory.heapUsed += s.memory.heapUsed;
-                for (const [path, count] of Object.entries(s.successEp)) {
-                    agg.successEp[path] = (agg.successEp[path] || 0) + count;
-                }
-                for (const [path, count] of Object.entries(s.failEp)) {
-                    agg.failEp[path] = (agg.failEp[path] || 0) + count;
-                }
-                for (const [url, count] of Object.entries(s.http)) {
-                    agg.http[url] = (agg.http[url] || 0) + count;
-                }
-                for (const [query, count] of Object.entries(s.success_sql)) {
-                    agg.success_sql[query] = (agg.success_sql[query] || 0) + count;
-                }
-                for (const [query, count] of Object.entries(s.fail_sql)) {
-                    agg.fail_sql[query] = (agg.fail_sql[query] || 0) + count;
-                }
+                agg.memory.heapTotal += s.memory.heapTotal;
+                agg.memory.external += s.memory.external;
+                sum(agg.successEp, s.successEp);
+                sum(agg.failEp, s.failEp);
+                sum(agg.http, s.http);
+                sum(agg.http_ok, s.http_ok);
+                sum(agg.http_fail, s.http_fail);
+                sum(agg.success_sql, s.success_sql);
+                sum(agg.fail_sql, s.fail_sql);
+                maxInto(agg.httpP95, s.httpP95);
             });
             const len = chunk.length;
             agg.cpu = Number((agg.cpu / len).toFixed(2));
             agg.memory.rss = Math.round(agg.memory.rss / len);
             agg.memory.heapUsed = Math.round(agg.memory.heapUsed / len);
+            agg.memory.heapTotal = Math.round(agg.memory.heapTotal / len);
+            agg.memory.external = Math.round(agg.memory.external / len);
             result.push({
                 timestamp: this.slotToTimestamp(agg.yyyymmddhhii),
                 slot: agg
@@ -144,6 +192,7 @@ class MonitorService extends BaseService_1.BaseService {
         const usage = process.cpuUsage();
         const now = Date.now();
         const yyyymmddhhmm = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(new Date(now), "yyyymmddhhmm"));
+        this.finalizeLatency(yyyymmddhhmm);
         const slot = this.getSlot(yyyymmddhhmm);
         if (this.lastCpuUsage && this.lastTimestamp) {
             const diff = usage.user - this.lastCpuUsage.user;
@@ -160,6 +209,8 @@ class MonitorService extends BaseService_1.BaseService {
             heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
             external: Math.round(mem.external / 1024 / 1024),
         };
+        if (this.metricsDir && this._persistReady)
+            await this.persistTick().catch(() => { });
     }
     static MAX_SLOT_KEYS = 100;
     static normalizeQuery(query) {
@@ -200,6 +251,42 @@ class MonitorService extends BaseService_1.BaseService {
         const slot = this.getSlot(yyyymmddhhmm);
         this.bumpCappedKey(slot.http, MonitorService.normalizeUrl(data.url));
     }
+    _latByMinute = new Map();
+    static LAT_CAP_PER_MIN = 3000;
+    onHttpResultRegistrate(data) {
+        const minuteKey = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(new Date(), "yyyymmddhhmm"));
+        const slot = this.getSlot(minuteKey);
+        this.bumpCappedKey(data.ok ? slot.http_ok : slot.http_fail, data.host);
+        let hosts = this._latByMinute.get(minuteKey);
+        if (!hosts) {
+            hosts = new Map();
+            this._latByMinute.set(minuteKey, hosts);
+        }
+        let arr = hosts.get(data.host);
+        if (!arr) {
+            arr = [];
+            hosts.set(data.host, arr);
+        }
+        if (arr.length < MonitorService.LAT_CAP_PER_MIN)
+            arr.push(data.ms);
+    }
+    finalizeLatency(currentMinute, includeCurrent = false) {
+        for (const [minuteKey, hosts] of this._latByMinute) {
+            if (includeCurrent ? minuteKey > currentMinute : minuteKey >= currentMinute)
+                continue;
+            const slot = this.slots.get(Math.floor(minuteKey / 100))?.get(minuteKey);
+            if (slot) {
+                for (const [host, samples] of hosts) {
+                    if (!samples.length)
+                        continue;
+                    samples.sort((a, b) => a - b);
+                    const idx = Math.min(samples.length - 1, Math.max(0, Math.ceil(0.95 * samples.length) - 1));
+                    slot.httpP95[host] = samples[idx];
+                }
+            }
+            this._latByMinute.delete(minuteKey);
+        }
+    }
     onSQLRequestRegistrate(data) {
         const date = new Date();
         const yyyymmddhhmm = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(date, "yyyymmddhhmm"));
@@ -233,6 +320,9 @@ class MonitorService extends BaseService_1.BaseService {
                 successEp: {},
                 failEp: {},
                 http: {},
+                http_ok: {},
+                http_fail: {},
+                httpP95: {},
                 success_sql: {},
                 fail_sql: {}
             };
@@ -240,5 +330,285 @@ class MonitorService extends BaseService_1.BaseService {
         }
         return slot;
     }
+    liveFile(weekKey) {
+        return path_1.default.join(this.metricsDir, `metrics_${weekKey}.jsonl`);
+    }
+    archiveFile(weekKey) {
+        return path_1.default.join(this.metricsDir, `metrics_${weekKey}.json`);
+    }
+    weekKey(date) {
+        const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+        const dayNum = (d.getUTCDay() + 6) % 7;
+        d.setUTCDate(d.getUTCDate() - dayNum + 3);
+        const firstThursday = new Date(Date.UTC(d.getUTCFullYear(), 0, 4));
+        const firstDayNum = (firstThursday.getUTCDay() + 6) % 7;
+        firstThursday.setUTCDate(firstThursday.getUTCDate() - firstDayNum + 3);
+        const week = 1 + Math.round((d.getTime() - firstThursday.getTime()) / (7 * 24 * 3600 * 1000));
+        return `${d.getUTCFullYear()}-W${String(week).padStart(2, "0")}`;
+    }
+    async atomicWrite(file, content) {
+        const tmp = file + ".tmp";
+        await promises_1.default.writeFile(tmp, content, "utf-8");
+        await promises_1.default.rename(tmp, file);
+    }
+    normalizeSlot(raw) {
+        if (!raw || typeof raw !== "object")
+            return null;
+        const key = Number(raw.yyyymmddhhii);
+        if (!Number.isFinite(key))
+            return null;
+        const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+        const rec = (v) => {
+            const out = {};
+            if (v && typeof v === "object" && !Array.isArray(v))
+                for (const [k, val] of Object.entries(v))
+                    if (typeof val === "number" && Number.isFinite(val))
+                        out[k] = val;
+            return out;
+        };
+        const m = raw.memory && typeof raw.memory === "object" ? raw.memory : {};
+        return {
+            yyyymmddhhii: key,
+            cpu: num(raw.cpu),
+            memory: { rss: num(m.rss), heapUsed: num(m.heapUsed), heapTotal: num(m.heapTotal), external: num(m.external) },
+            successEp: rec(raw.successEp), failEp: rec(raw.failEp),
+            http: rec(raw.http), http_ok: rec(raw.http_ok), http_fail: rec(raw.http_fail), httpP95: rec(raw.httpP95),
+            success_sql: rec(raw.success_sql), fail_sql: rec(raw.fail_sql),
+        };
+    }
+    async readJsonl(file) {
+        const txt = await promises_1.default.readFile(file, "utf-8");
+        const out = [];
+        for (const line of txt.split("\n")) {
+            const t = line.trim();
+            if (!t)
+                continue;
+            try {
+                const s = this.normalizeSlot(JSON.parse(t));
+                if (s)
+                    out.push(s);
+            }
+            catch { }
+        }
+        return out;
+    }
+    async persistTick(includeCurrentMinute = false) {
+        if (!this.metricsDir)
+            return;
+        const nowKey = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(new Date(), "yyyymmddhhmm"));
+        this.finalizeLatency(nowKey, includeCurrentMinute);
+        const pending = [];
+        for (const dayMap of this.slots.values()) {
+            for (const slot of dayMap.values()) {
+                const k = slot.yyyymmddhhii;
+                if (k <= this._flushedUpTo)
+                    continue;
+                if (!includeCurrentMinute && k >= nowKey)
+                    continue;
+                pending.push(slot);
+            }
+        }
+        pending.sort((a, b) => a.yyyymmddhhii - b.yyyymmddhhii);
+        if (pending.length) {
+            try {
+                const byWeek = new Map();
+                for (const s of pending) {
+                    const wk = this.weekKey(new Date(this.slotToTimestamp(s.yyyymmddhhii)));
+                    byWeek.set(wk, (byWeek.get(wk) ?? "") + JSON.stringify(s) + "\n");
+                }
+                for (const [wk, text] of byWeek)
+                    await promises_1.default.appendFile(this.liveFile(wk), text, "utf-8");
+                this._flushedUpTo = pending[pending.length - 1].yyyymmddhhii;
+            }
+            catch (e) {
+                (0, LogService_1.logWarn)("metrics: persist append failed: " + (e?.message ?? e));
+            }
+        }
+        const curWeek = this.weekKey(new Date());
+        if (this._lastSeenWeekKey && this._lastSeenWeekKey !== curWeek)
+            await this.rotate().catch(() => { });
+        this._lastSeenWeekKey = curWeek;
+    }
+    async rotate() {
+        if (!this.metricsDir)
+            return;
+        try {
+            const curWeek = this.weekKey(new Date());
+            const files = await promises_1.default.readdir(this.metricsDir);
+            for (const f of files) {
+                const m = f.match(/^metrics_(\d{4}-W\d{2})\.jsonl$/);
+                if (m && m[1] !== curWeek)
+                    await this.downsampleWeek(m[1]);
+            }
+            const after = await promises_1.default.readdir(this.metricsDir);
+            const byWeek = new Map();
+            for (const f of after) {
+                const m = f.match(/^metrics_(\d{4}-W\d{2})\.(jsonl|json)$/);
+                if (!m)
+                    continue;
+                const arr = byWeek.get(m[1]) ?? [];
+                arr.push(f);
+                byWeek.set(m[1], arr);
+            }
+            const weeks = Array.from(byWeek.keys()).sort();
+            const excess = weeks.slice(0, Math.max(0, weeks.length - MonitorService.MAX_WEEKS));
+            for (const wk of excess)
+                for (const f of byWeek.get(wk))
+                    await promises_1.default.unlink(path_1.default.join(this.metricsDir, f)).catch(() => { });
+        }
+        catch (e) {
+            (0, LogService_1.logWarn)("metrics: rotate failed: " + (e?.message ?? e));
+        }
+    }
+    async downsampleWeek(weekKey) {
+        const live = this.liveFile(weekKey);
+        let slots;
+        try {
+            slots = await this.readJsonl(live);
+        }
+        catch {
+            return;
+        }
+        if (!slots.length) {
+            await promises_1.default.unlink(live).catch(() => { });
+            return;
+        }
+        const byHour = new Map();
+        for (const s of slots) {
+            const hourKey = Math.floor(s.yyyymmddhhii / 100) * 100;
+            const arr = byHour.get(hourKey) ?? [];
+            arr.push(s);
+            byHour.set(hourKey, arr);
+        }
+        const hourly = Array.from(byHour.entries())
+            .sort((a, b) => a[0] - b[0])
+            .map(([hourKey, arr]) => this.mergeSlots(hourKey, arr));
+        await this.atomicWrite(this.archiveFile(weekKey), JSON.stringify({ version: MonitorService.SCHEMA_VERSION, weekKey, resolution: "hour", slots: hourly }));
+        await promises_1.default.unlink(live).catch(() => { });
+    }
+    mergeSlots(key, arr) {
+        const out = {
+            yyyymmddhhii: key, cpu: 0,
+            memory: { rss: 0, heapUsed: 0, heapTotal: 0, external: 0 },
+            successEp: {}, failEp: {}, http: {}, http_ok: {}, http_fail: {}, httpP95: {},
+            success_sql: {}, fail_sql: {},
+        };
+        const add = (dst, src) => {
+            if (!src)
+                return;
+            for (const [k, v] of Object.entries(src))
+                dst[k] = (dst[k] || 0) + v;
+        };
+        const maxInto = (dst, src) => {
+            if (!src)
+                return;
+            for (const [k, v] of Object.entries(src))
+                dst[k] = Math.max(dst[k] || 0, v);
+        };
+        for (const s of arr) {
+            out.cpu += s.cpu;
+            out.memory.rss += s.memory.rss;
+            out.memory.heapUsed += s.memory.heapUsed;
+            out.memory.heapTotal += s.memory.heapTotal;
+            out.memory.external += s.memory.external;
+            add(out.successEp, s.successEp);
+            add(out.failEp, s.failEp);
+            add(out.http, s.http);
+            add(out.http_ok, s.http_ok);
+            add(out.http_fail, s.http_fail);
+            add(out.success_sql, s.success_sql);
+            add(out.fail_sql, s.fail_sql);
+            maxInto(out.httpP95, s.httpP95);
+        }
+        const n = arr.length || 1;
+        out.cpu = Number((out.cpu / n).toFixed(2));
+        out.memory.rss = Math.round(out.memory.rss / n);
+        out.memory.heapUsed = Math.round(out.memory.heapUsed / n);
+        out.memory.heapTotal = Math.round(out.memory.heapTotal / n);
+        out.memory.external = Math.round(out.memory.external / n);
+        return out;
+    }
+    async hydrate() {
+        if (!this.metricsDir)
+            return;
+        try {
+            const cutoff = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(new Date(Date.now() - 7 * 24 * 3600 * 1000), "yyyymmddhhmm"));
+            const weeks = new Set([
+                this.weekKey(new Date()),
+                this.weekKey(new Date(Date.now() - 7 * 24 * 3600 * 1000)),
+            ]);
+            let maxKey = 0;
+            for (const wk of weeks) {
+                let slots;
+                try {
+                    slots = await this.readJsonl(this.liveFile(wk));
+                }
+                catch {
+                    continue;
+                }
+                for (const s of slots) {
+                    if (s.yyyymmddhhii < cutoff)
+                        continue;
+                    const dayKey = Math.floor(s.yyyymmddhhii / 100);
+                    let dayMap = this.slots.get(dayKey);
+                    if (!dayMap) {
+                        dayMap = new Map();
+                        this.slots.set(dayKey, dayMap);
+                    }
+                    dayMap.set(s.yyyymmddhhii, s);
+                    if (s.yyyymmddhhii > maxKey)
+                        maxKey = s.yyyymmddhhii;
+                }
+            }
+            this._flushedUpTo = maxKey;
+            while (this.slots.size > 7) {
+                const oldest = Array.from(this.slots.keys()).sort((a, b) => a - b)[0];
+                this.slots.delete(oldest);
+            }
+        }
+        catch (e) {
+            (0, LogService_1.logWarn)("metrics: hydrate failed: " + (e?.message ?? e));
+        }
+    }
+    async listPersistedWeeks() {
+        if (!this.metricsDir)
+            return [];
+        try {
+            const files = await promises_1.default.readdir(this.metricsDir);
+            const weeks = new Set();
+            for (const f of files) {
+                const m = f.match(/^metrics_(\d{4}-W\d{2})\.(jsonl|json)$/);
+                if (m)
+                    weeks.add(m[1]);
+            }
+            return Array.from(weeks).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    async readPersistedWeek(weekKey) {
+        if (!this.metricsDir || !/^\d{4}-W\d{2}$/.test(weekKey))
+            return [];
+        let slots = [];
+        try {
+            try {
+                slots = await this.readJsonl(this.liveFile(weekKey));
+            }
+            catch {
+                const txt = await promises_1.default.readFile(this.archiveFile(weekKey), "utf-8");
+                const rawSlots = JSON.parse(txt)?.slots;
+                slots = Array.isArray(rawSlots)
+                    ? rawSlots.map((r) => this.normalizeSlot(r)).filter((s) => s !== null)
+                    : [];
+            }
+        }
+        catch {
+            return [];
+        }
+        return slots
+            .sort((a, b) => a.yyyymmddhhii - b.yyyymmddhhii)
+            .map(s => ({ timestamp: this.slotToTimestamp(s.yyyymmddhhii), slot: s }));
+    }
 }
 exports.MonitorService = MonitorService;