badmfck-api-server 3.9.98 → 3.9.99

package/dist/apiServer/APIService.js

@@ -93,7 +93,7 @@ async function Initializer(services) {
 }
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
-    version = "3.9.98";
+    version = "3.9.99";
     options;
     monitor = null;
     started = new Date();
@@ -430,6 +430,7 @@ class APIService extends BaseService_1.BaseService {
                 this.addNetlog(data, req, requestTime, 0);
             return;
         }
+        MonitorService_1.S_STAT_REGISTRATE_REQUEST.invoke(data);
         if (this.options.postproducer) {
             try {
                 data = await this.options.postproducer(req, res, data, requestTime, endpoint);
@@ -445,7 +446,6 @@ class APIService extends BaseService_1.BaseService {
         data.endpoint = endpoint ?? "no_endpoint";
         if (this.options.appVersion)
             data.version = this.options.appVersion;
-        MonitorService_1.S_STAT_REGISTRATE_REQUEST.invoke(data);
         if (res.socket?.destroyed || res.writableEnded || res.headersSent || (res.destroyed !== undefined && res.destroyed)) {
             (0, LogService_1.logAPI)("Connection already closed, can't send response for: " + data.endpoint);
         }

package/dist/apiServer/MonitorService.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import Signal, { Req } from "badmfck-signal";
 import { BaseService } from "./BaseService";
 import { TransferPacketVO } from "./structures/Interfaces";
@@ -5,55 +6,48 @@ export interface ICustomEvent {
     event: string;
     data?: any;
 }
-export interface IEPStatReqFilter {
-    range?: "minute" | "hour" | "day";
-    from?: string;
-    to?: string;
-    ep?: string;
-    project?: string;
-    event?: string;
+export interface IStat {
+    timestamp: number;
+    slot: IMonitorSlot;
 }
 export declare const S_STAT_REGISTRATE_REQUEST: Signal<TransferPacketVO<any>>;
 export declare const S_STAT_REGISTRATE_CUSTOM_EVENT: Signal<ICustomEvent>;
 export declare const S_STAT_REGISTRATE_SERVICE: Signal<string>;
-export declare const REQ_EP_STAT: Req<void, Record<string, IMonitorDaySlot[]>>;
-export declare const REQ_MONITOR_CPU_STAT: Req<void, any>;
-type IMonitorMinutesSlot = {
-    count: number;
-    yyyymmddhhmm: number;
-};
-type IMonitorHoursSlot = {
-    count: number;
-    yyyymmddhh: number;
-    minutes: IMonitorMinutesSlot[];
-};
-type IMonitorDaySlot = {
-    ep: string;
-    yyyymmdd: number;
-    count: number;
-    hours: IMonitorHoursSlot[];
+export declare const S_STAT_REGISTRATE_HTTP_REQUEST: Signal<{
+    url: string;
+}>;
+export declare const REQ_STAT: Req<{
+    range: "week" | "day" | "hour";
+}, IStat[]>;
+type IMonitorSlot = {
+    yyyymmddhhii: number;
+    cpu: number;
+    memory: {
+        rss: number;
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+    };
+    externalCalls?: number;
+    successEp: Record<string, number>;
+    failEp: Record<string, number>;
+    http: Record<string, number>;
 };
 export declare class MonitorService extends BaseService {
-    private prevCpu;
-    private prevHrTime;
-    readonly intervalMs = 10000;
-    readonly maxSlots: number;
-    private history;
-    stat: Map<string, IMonitorDaySlot[]>;
+    slots: Map<number, Map<number, IMonitorSlot>>;
+    intervalMs: number;
+    lastCpuUsage: NodeJS.CpuUsage | null;
+    lastTimestamp: number | null;
     constructor();
     init(): Promise<void>;
-    getEPStat(): Promise<Record<string, IMonitorDaySlot[]>>;
+    getEPStat(req: {
+        range: "week" | "day" | "hour";
+    }): Promise<IStat[]>;
+    private aggregate;
+    private slotToTimestamp;
     onStatRegistrate(data: TransferPacketVO): void;
-    private collectUsage;
-    getUsage(): {
-        timestamp: number;
-        cpu: number;
-        memory: {
-            rss: number;
-            heapUsed: number;
-            heapTotal: number;
-            external: number;
-        };
-    }[];
+    collectUsage(): Promise<void>;
+    private onHttpRequestRegistrate;
+    private getSlot;
 }
 export {};

package/dist/apiServer/MonitorService.js

@@ -22,103 +22,161 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MonitorService = exports.REQ_MONITOR_CPU_STAT = exports.REQ_EP_STAT = exports.S_STAT_REGISTRATE_SERVICE = exports.S_STAT_REGISTRATE_CUSTOM_EVENT = exports.S_STAT_REGISTRATE_REQUEST = void 0;
+exports.MonitorService = exports.REQ_STAT = 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 os_1 = __importDefault(require("os"));
 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.REQ_EP_STAT = new badmfck_signal_1.Req(undefined, "REQ_EP_STAT");
-exports.REQ_MONITOR_CPU_STAT = new badmfck_signal_1.Req(undefined, "REQ_MONITOR_CPU_STAT");
+exports.S_STAT_REGISTRATE_HTTP_REQUEST = new badmfck_signal_1.default();
+exports.REQ_STAT = new badmfck_signal_1.Req(undefined, "REQ_STAT");
 class MonitorService extends BaseService_1.BaseService {
-    prevCpu = process.cpuUsage();
-    prevHrTime = process.hrtime();
-    intervalMs = 10_000;
-    maxSlots = (5 * 60 * 1000) / this.intervalMs;
-    history = [];
-    stat = new Map();
+    slots = new Map();
+    intervalMs = 59_000;
+    lastCpuUsage = null;
+    lastTimestamp = null;
     constructor() {
         super("MonitorService");
-        exports.S_STAT_REGISTRATE_REQUEST.subscribe((req) => this.onStatRegistrate(req));
-        exports.REQ_EP_STAT.listener = async (req) => this.getEPStat();
-        exports.REQ_MONITOR_CPU_STAT.listener = async () => this.getUsage();
         setInterval(() => this.collectUsage(), this.intervalMs);
     }
     async init() {
         super.init();
+        exports.REQ_STAT.listener = async (req) => this.getEPStat(req);
+        exports.S_STAT_REGISTRATE_HTTP_REQUEST.subscribe((data) => this.onHttpRequestRegistrate(data));
+        exports.S_STAT_REGISTRATE_REQUEST.subscribe((data) => this.onStatRegistrate(data));
+    }
+    async getEPStat(req) {
+        const allSlots = [];
+        const sortedDayKeys = Array.from(this.slots.keys()).sort((a, b) => a - b);
+        for (const dayKey of sortedDayKeys) {
+            const dayMap = this.slots.get(dayKey);
+            const sortedMinKeys = Array.from(dayMap.keys()).sort((a, b) => a - b);
+            for (const minKey of sortedMinKeys) {
+                allSlots.push(dayMap.get(minKey));
+            }
+        }
+        const steps = { hour: 1, day: 10, week: 30 };
+        const step = steps[req.range] || 1;
+        const limits = { hour: 60, day: 1440, week: 7200 };
+        const limitedSlots = allSlots.slice(-(limits[req.range] || 60));
+        return this.aggregate(limitedSlots, step);
     }
-    async getEPStat() {
-        const result = {};
-        for (const [ep, slots] of this.stat.entries())
-            result[ep] = slots;
+    aggregate(allSlots, step) {
+        const result = [];
+        for (let i = 0; i < allSlots.length; i += step) {
+            const chunk = allSlots.slice(i, i + step);
+            const first = chunk[0];
+            const agg = {
+                yyyymmddhhii: first.yyyymmddhhii,
+                cpu: 0,
+                memory: { rss: 0, heapUsed: 0, heapTotal: 0, external: 0 },
+                successEp: {},
+                failEp: {},
+                http: {}
+            };
+            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;
+                }
+            });
+            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);
+            result.push({
+                timestamp: this.slotToTimestamp(agg.yyyymmddhhii),
+                slot: agg
+            });
+        }
         return result;
     }
+    slotToTimestamp(val) {
+        const s = val.toString();
+        return new Date(+s.substring(0, 4), +s.substring(4, 6) - 1, +s.substring(6, 8), +s.substring(8, 10), +s.substring(10, 12)).getTime();
+    }
     onStatRegistrate(data) {
         const date = new Date();
         const yyyymmdd = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(date, "yyyymmdd"));
-        const yyyymmddhh = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(date, "yyyymmddhh"));
         const yyyymmddhhmm = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(date, "yyyymmddhhmm"));
         const ep = data.endpoint || "unknown";
-        let epSlot = this.stat.get(ep);
-        if (!epSlot) {
-            epSlot = [];
-            this.stat.set(ep, epSlot);
-        }
-        let slot = epSlot.find((s) => s.yyyymmdd === yyyymmdd && s.ep === ep);
-        if (!slot) {
-            slot = { ep, yyyymmdd: yyyymmdd, count: 0, hours: [] };
-            epSlot.push(slot);
+        const slot = this.getSlot(yyyymmddhhmm);
+        if (!data.error)
+            slot.successEp[ep] = (slot.successEp[ep] || 0) + 1;
+        else
+            slot.failEp[ep] = (slot.failEp[ep] || 0) + 1;
+    }
+    async collectUsage() {
+        const usage = process.cpuUsage();
+        const now = Date.now();
+        const yyyymmddhhmm = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(new Date(now), "yyyymmddhhmm"));
+        const slot = this.getSlot(yyyymmddhhmm);
+        if (this.lastCpuUsage && this.lastTimestamp) {
+            const diff = usage.user - this.lastCpuUsage.user;
+            const sysdiff = usage.system - this.lastCpuUsage.system;
+            const timeDiffMs = now - this.lastTimestamp;
+            slot.cpu = Number(((diff + sysdiff) / 1000 / timeDiffMs / os_1.default.cpus().length * 100).toFixed(2));
         }
-        slot.count++;
-        let slotHour = slot.hours.find((h) => h.yyyymmddhh === yyyymmddhh);
-        if (!slotHour) {
-            slotHour = {
-                count: 0,
-                yyyymmddhh,
-                minutes: [],
-            };
-            slot.hours.push(slotHour);
+        this.lastCpuUsage = usage;
+        this.lastTimestamp = now;
+        const mem = process.memoryUsage();
+        slot.memory = {
+            rss: Math.round(mem.rss / 1024 / 1024),
+            heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
+            heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
+            external: Math.round(mem.external / 1024 / 1024),
+        };
+    }
+    onHttpRequestRegistrate(data) {
+        const date = new Date();
+        const yyyymmddhhmm = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(date, "yyyymmddhhmm"));
+        const slot = this.getSlot(yyyymmddhhmm);
+        slot.http[data.url] = (slot.http[data.url] || 0) + 1;
+    }
+    getSlot(yyyymmddhhii) {
+        const yyymmdd = Math.floor(yyyymmddhhii / 100);
+        let daySlots = this.slots.get(yyymmdd);
+        if (!daySlots) {
+            daySlots = new Map();
+            this.slots.set(yyymmdd, daySlots);
+            if (this.slots.size > 7) {
+                let key = this.slots.keys().next().value;
+                if (key)
+                    this.slots.delete(key);
+            }
         }
-        slotHour.count++;
-        let slotMinute = slotHour.minutes.find((m) => m.yyyymmddhhmm === yyyymmddhhmm);
-        if (!slotMinute) {
-            slotMinute = {
-                count: 0,
-                yyyymmddhhmm,
+        let slot = daySlots.get(yyyymmddhhii);
+        if (!slot) {
+            slot = {
+                yyyymmddhhii,
+                cpu: 0,
+                memory: {
+                    rss: 0,
+                    heapUsed: 0,
+                    heapTotal: 0,
+                    external: 0,
+                },
+                successEp: {},
+                failEp: {},
+                http: {}
             };
-            slotHour.minutes.push(slotMinute);
+            daySlots.set(yyyymmddhhii, slot);
         }
-        slotMinute.count++;
-        if (epSlot.length > 7)
-            epSlot.unshift();
-    }
-    collectUsage() {
-        const currentCpu = process.cpuUsage(this.prevCpu);
-        const currentHrTime = process.hrtime(this.prevHrTime);
-        this.prevCpu = process.cpuUsage();
-        this.prevHrTime = process.hrtime();
-        const elapsedMicros = currentHrTime[0] * 1e6 + currentHrTime[1] / 1e3;
-        const totalCpu = currentCpu.user + currentCpu.system;
-        const cpuPercent = (totalCpu / elapsedMicros) * 100;
-        const mem = process.memoryUsage();
-        this.history.push({
-            timestamp: Date.now(),
-            cpu: cpuPercent,
-            memory: {
-                rss: mem.rss,
-                heapUsed: mem.heapUsed,
-                heapTotal: mem.heapTotal,
-                external: mem.external,
-            },
-        });
-        if (this.history.length > this.maxSlots) {
-            this.history.shift();
-        }
-    }
-    getUsage() {
-        return this.history;
+        return slot;
     }
 }
 exports.MonitorService = MonitorService;

package/dist/apiServer/http/HTTP.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Http = void 0;
 const undici_1 = require("undici");
 const node_diagnostics_channel_1 = __importDefault(require("node:diagnostics_channel"));
+const MonitorService_1 = require("../MonitorService");
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
@@ -227,6 +228,7 @@ class Http {
         };
     }
     static async request(opts) {
+        MonitorService_1.S_STAT_REGISTRATE_HTTP_REQUEST.invoke({ url: opts.url });
         this.ensureInit();
         const cfg = this.config;
         const retryCfg = {

package/dist/apiServer/monitor/Monitor.d.ts

@@ -5,19 +5,12 @@ import { HTTPRequestVO, TransferPacketVO } from "../structures/Interfaces";
 export interface IUserAction {
     action: string;
 }
-interface IStatObject {
-    requests: Map<string, number>;
-    errors: Map<string, number>;
-    fatalErrors: Map<string, number>;
-    apiErrors: Map<string, number>;
-}
 export declare const S_MONITOR_REGISTRATE_ACTION: Signal<IUserAction>;
 export declare class Monitor extends BaseEndpoint {
     ignoreHttpLogging: boolean;
     ignoreInDocumentation: boolean;
     indexHtmlFile: string | null;
     apiServiceOptions: APIServiceOptions;
-    users: Map<string, IStatObject>;
     fileParsed: boolean;
     lastTimeCacheChecked: number;
     constructor(options: APIServiceOptions);
@@ -28,7 +21,5 @@ export declare class Monitor extends BaseEndpoint {
     logs(req: HTTPRequestVO): Promise<TransferPacketVO>;
     netlog(req: HTTPRequestVO): Promise<TransferPacketVO>;
     metrics(req: HTTPRequestVO): Promise<TransferPacketVO>;
-    serverStat(req: HTTPRequestVO): Promise<TransferPacketVO>;
     checkAuthentication(req: HTTPRequestVO): Promise<void>;
 }
-export {};

package/dist/apiServer/monitor/Monitor.js

@@ -10,10 +10,10 @@ const BaseEndpoint_1 = require("../BaseEndpoint");
 const LogService_1 = require("../LogService");
 const crypto_1 = __importDefault(require("crypto"));
 const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
-const MonitorService_1 = require("../MonitorService");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const Http_1 = require("../http/Http");
+const MonitorService_1 = require("../MonitorService");
 exports.S_MONITOR_REGISTRATE_ACTION = new badmfck_signal_1.Signal();
 const logMap = {
     ALL: 10,
@@ -29,7 +29,6 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
     ignoreInDocumentation = true;
     indexHtmlFile = null;
     apiServiceOptions;
-    users = new Map();
     fileParsed = false;
     lastTimeCacheChecked = 0;
     constructor(options) {
@@ -39,8 +38,10 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
             { ignoreInterceptor: true, endpoint: "html", handler: this.html },
             { ignoreInterceptor: true, endpoint: "log", handler: this.logs },
             { ignoreInterceptor: true, endpoint: "netlog", handler: this.netlog },
-            { ignoreInterceptor: true, endpoint: "metrics", handler: this.metrics },
-            { ignoreInterceptor: true, endpoint: "server", handler: this.serverStat },
+            { ignoreInterceptor: true, endpoint: "metrics", handler: this.metrics, validationModel: {
+                    range: "",
+                    $__range_values: ["week", "day", "hour"]
+                } },
             { ignoreInterceptor: true, endpoint: "controllers", handler: this.controllers },
             { ignoreInterceptor: true, endpoint: "changeLogLevel", handler: this.changeLogLevel, validationModel: {
                     level: Object.keys(logMap).join(",")
@@ -125,13 +126,9 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
     }
     async metrics(req) {
         await this.checkAuthentication(req);
-        const result = await MonitorService_1.REQ_EP_STAT.request(req.data);
+        const result = await MonitorService_1.REQ_STAT.request(req.data);
         return { data: result };
     }
-    async serverStat(req) {
-        await this.checkAuthentication(req);
-        return { data: MonitorService_1.REQ_MONITOR_CPU_STAT.request() };
-    }
     async checkAuthentication(req) {
         const users = await APIService_1.REQ_MONITOR_USERS.request();
         if (!users || users.length == 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "3.9.98",
+  "version": "3.9.99",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",