badmfck-api-server 4.1.25 → 4.1.27

package/dist/apiServer/http/Http.d.ts

@@ -13,6 +13,60 @@ export type THttpErr<E = any> = {
     details?: any;
 };
 export type THttpResult<T, E = any> = THttpOk<T> | THttpErr<E>;
+export type THttpOutgoingLogItem = {
+    id: number;
+    created: number;
+    time: number;
+    method: HttpMethod;
+    url: string;
+    status?: number;
+    ok: boolean;
+    attempts: number;
+    request: any;
+    response: any;
+    error?: string;
+};
+export type THttpHostStats = {
+    host: string;
+    count: number;
+    errors: number;
+    timeouts: number;
+    retries: number;
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    totalTimeMs: number;
+    inFlight: number;
+    byStatus: {
+        s2xx: number;
+        s3xx: number;
+        s4xx: number;
+        s5xx: number;
+        other: number;
+        networkErrors: number;
+    };
+    lastRequestAt: number;
+};
+export type THttpStatusDistribution = {
+    s2xx: number;
+    s3xx: number;
+    s4xx: number;
+    s5xx: number;
+    other: number;
+    networkErrors: number;
+    timeouts: number;
+};
+export type THttpStatsSnapshot = {
+    totalRequests: number;
+    inFlight: {
+        current: number;
+        peak: number;
+        byHost: Record<string, number>;
+    };
+    statusDistribution: THttpStatusDistribution;
+    perHost: THttpHostStats[];
+    topSlow: THttpOutgoingLogItem[];
+};
 export type TRetryPolicy = {
     enabled?: boolean;
     maxAttempts?: number;
@@ -71,6 +125,27 @@ export declare class Http {
     private static _activeConnectionsByHost;
     private static _countedSockets;
     private static _socketHostKey;
+    private static _outgoingLog;
+    private static _nextOutgoingLogID;
+    private static _outgoingLogLimit;
+    private static _truncate;
+    private static _pushOutgoingLog;
+    static getOutgoingLogSnapshot(): THttpOutgoingLogItem[];
+    private static _totalRequests;
+    private static _inFlight;
+    private static _peakInFlight;
+    private static _inFlightByHost;
+    private static _statusDist;
+    private static _perHost;
+    private static _topSlow;
+    private static _topSlowLimit;
+    private static _hostFromUrl;
+    private static _isTimeoutError;
+    private static _incInFlight;
+    private static _decInFlight;
+    private static _updateStats;
+    private static _pushToTopSlow;
+    static getHttpStats(): THttpStatsSnapshot;
     private static ensureInit;
     static configure(partial: Partial<THttpConfig>): void;
     static createAgent(opts?: ConstructorParameters<typeof Agent>[0]): Agent;

package/dist/apiServer/http/Http.js

@@ -88,6 +88,179 @@ class Http {
     static _activeConnectionsByHost = new Map();
     static _countedSockets = new WeakSet();
     static _socketHostKey = new WeakMap();
+    static _outgoingLog = [];
+    static _nextOutgoingLogID = 0;
+    static _outgoingLogLimit = 500;
+    static _truncate(v) {
+        if (v === undefined || v === null)
+            return v;
+        if (Buffer.isBuffer(v))
+            return `[Buffer ${v.length} bytes]`;
+        let json = "";
+        try {
+            json = JSON.stringify(v, (_, val) => {
+                if (typeof val === "string" && val.length > 255)
+                    return val.slice(0, 255) + `...(${val.length})`;
+                if (Buffer.isBuffer(val))
+                    return `[Buffer ${val.length} bytes]`;
+                return val;
+            });
+        }
+        catch {
+            return "[unserializable]";
+        }
+        return json.length > 500 ? json.slice(0, 500) + `...(total ${json.length})` : json;
+    }
+    static _pushOutgoingLog(item) {
+        const entry = { id: this._nextOutgoingLogID++, ...item };
+        this._outgoingLog.push(entry);
+        if (this._outgoingLog.length > this._outgoingLogLimit)
+            this._outgoingLog.shift();
+        if (this._nextOutgoingLogID > Number.MAX_SAFE_INTEGER - 1000)
+            this._nextOutgoingLogID = 0;
+        return entry;
+    }
+    static getOutgoingLogSnapshot() {
+        return this._outgoingLog.slice();
+    }
+    static _totalRequests = 0;
+    static _inFlight = 0;
+    static _peakInFlight = 0;
+    static _inFlightByHost = new Map();
+    static _statusDist = {
+        s2xx: 0, s3xx: 0, s4xx: 0, s5xx: 0, other: 0, networkErrors: 0, timeouts: 0,
+    };
+    static _perHost = new Map();
+    static _topSlow = [];
+    static _topSlowLimit = 20;
+    static _hostFromUrl(url) {
+        try {
+            return new URL(url).host || "unknown";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    static _isTimeoutError(err) {
+        if (!err || typeof err !== "object")
+            return false;
+        const e = err;
+        if (e.name === "AbortError")
+            return true;
+        if (typeof e.code === "string" && e.code.includes("TIMEOUT"))
+            return true;
+        return false;
+    }
+    static _incInFlight(host) {
+        this._inFlight++;
+        if (this._inFlight > this._peakInFlight)
+            this._peakInFlight = this._inFlight;
+        this._inFlightByHost.set(host, (this._inFlightByHost.get(host) ?? 0) + 1);
+    }
+    static _decInFlight(host) {
+        this._inFlight = Math.max(0, this._inFlight - 1);
+        const prev = this._inFlightByHost.get(host) ?? 0;
+        const next = Math.max(0, prev - 1);
+        if (next === 0)
+            this._inFlightByHost.delete(host);
+        else
+            this._inFlightByHost.set(host, next);
+    }
+    static _updateStats(host, entry, isTimeout) {
+        this._totalRequests++;
+        if (typeof entry.status === "number") {
+            const s = entry.status;
+            if (s >= 200 && s < 300)
+                this._statusDist.s2xx++;
+            else if (s >= 300 && s < 400)
+                this._statusDist.s3xx++;
+            else if (s >= 400 && s < 500)
+                this._statusDist.s4xx++;
+            else if (s >= 500 && s < 600)
+                this._statusDist.s5xx++;
+            else
+                this._statusDist.other++;
+        }
+        else if (entry.error) {
+            this._statusDist.networkErrors++;
+            if (isTimeout)
+                this._statusDist.timeouts++;
+        }
+        let h = this._perHost.get(host);
+        if (!h) {
+            h = {
+                host,
+                count: 0, errors: 0, timeouts: 0, retries: 0,
+                avgMs: 0, minMs: Infinity, maxMs: 0, totalTimeMs: 0,
+                inFlight: 0,
+                byStatus: { s2xx: 0, s3xx: 0, s4xx: 0, s5xx: 0, other: 0, networkErrors: 0 },
+                lastRequestAt: 0,
+            };
+            this._perHost.set(host, h);
+        }
+        h.count++;
+        h.totalTimeMs += entry.time;
+        h.avgMs = Math.round((h.totalTimeMs / h.count) * 10) / 10;
+        if (entry.time < h.minMs)
+            h.minMs = entry.time;
+        if (entry.time > h.maxMs)
+            h.maxMs = entry.time;
+        if (!entry.ok)
+            h.errors++;
+        if (isTimeout)
+            h.timeouts++;
+        h.retries += Math.max(0, entry.attempts - 1);
+        h.lastRequestAt = Date.now();
+        if (typeof entry.status === "number") {
+            const s = entry.status;
+            if (s >= 200 && s < 300)
+                h.byStatus.s2xx++;
+            else if (s >= 300 && s < 400)
+                h.byStatus.s3xx++;
+            else if (s >= 400 && s < 500)
+                h.byStatus.s4xx++;
+            else if (s >= 500 && s < 600)
+                h.byStatus.s5xx++;
+            else
+                h.byStatus.other++;
+        }
+        else if (entry.error) {
+            h.byStatus.networkErrors++;
+        }
+    }
+    static _pushToTopSlow(entry) {
+        if (this._topSlow.length < this._topSlowLimit) {
+            this._topSlow.push(entry);
+            this._topSlow.sort((a, b) => b.time - a.time);
+            return;
+        }
+        const slowest_of_top = this._topSlow[this._topSlow.length - 1];
+        if (entry.time > slowest_of_top.time) {
+            this._topSlow.push(entry);
+            this._topSlow.sort((a, b) => b.time - a.time);
+            this._topSlow.pop();
+        }
+    }
+    static getHttpStats() {
+        const perHost = Array.from(this._perHost.values())
+            .map(h => ({
+            ...h,
+            minMs: Number.isFinite(h.minMs) ? h.minMs : 0,
+            inFlight: this._inFlightByHost.get(h.host) ?? 0,
+        }))
+            .sort((a, b) => b.count - a.count);
+        return {
+            totalRequests: this._totalRequests,
+            inFlight: {
+                current: this._inFlight,
+                peak: this._peakInFlight,
+                byHost: Object.fromEntries(this._inFlightByHost),
+            },
+            statusDistribution: { ...this._statusDist },
+            perHost,
+            topSlow: this._topSlow.slice(),
+        };
+    }
     static ensureInit() {
         if (this._inited)
             return;
@@ -230,6 +403,7 @@ class Http {
     static async request(opts) {
         MonitorService_1.S_STAT_REGISTRATE_HTTP_REQUEST.invoke({ url: opts.url });
         this.ensureInit();
+        const overallStarted = Date.now();
         const cfg = this.config;
         const retryCfg = {
             enabled: opts.retry?.enabled ?? cfg.retry?.enabled ?? true,
@@ -263,7 +437,30 @@ class Http {
         }
         const responseType = opts.responseType ?? "json";
         const throwOnJsonParseError = opts.throwOnJsonParseError ?? false;
+        let attemptsMade = 0;
+        const host = Http._hostFromUrl(url);
+        Http._incInFlight(host);
+        const finish = (result, networkErr) => {
+            Http._decInFlight(host);
+            const entry = Http._pushOutgoingLog({
+                created: overallStarted,
+                time: Date.now() - overallStarted,
+                method: opts.method,
+                url,
+                status: result.status,
+                ok: result.ok,
+                attempts: attemptsMade,
+                request: Http._truncate(opts.body),
+                response: Http._truncate(result.ok ? result.data : result.error),
+                error: networkErr ? String(networkErr?.message ?? networkErr) : undefined,
+            });
+            const isTimeout = Http._isTimeoutError(networkErr);
+            Http._updateStats(host, entry, isTimeout);
+            Http._pushToTopSlow(entry);
+            return result;
+        };
         for (let attempt = 1; attempt <= retryCfg.maxAttempts; attempt++) {
+            attemptsMade = attempt;
             const started = Date.now();
             cfg.onRequest?.({ method: opts.method, url, attempt });
             const controller = new AbortController();
@@ -307,7 +504,7 @@ class Http {
                     }
                 }
                 if (status >= 200 && status < 300) {
-                    return { ok: true, status, data: parsed, headers: hdrs };
+                    return finish({ ok: true, status, data: parsed, headers: hdrs });
                 }
                 const retryable = retryCfg.enabled &&
                     isRetryableStatus(status, retryCfg.retryOnStatuses) &&
@@ -317,7 +514,7 @@ class Http {
                     await sleep(backoff);
                     continue;
                 }
-                return { ok: false, status, error: parsed, details: { headers: hdrs } };
+                return finish({ ok: false, status, error: parsed, details: { headers: hdrs } });
             }
             catch (err) {
                 const ms = Date.now() - started;
@@ -331,13 +528,13 @@ class Http {
                     await sleep(backoff);
                     continue;
                 }
-                return { ok: false, error: err, details: { network: true } };
+                return finish({ ok: false, error: err, details: { network: true } }, err);
             }
             finally {
                 clearTimeout(t);
             }
         }
-        return { ok: false, error: "UNKNOWN" };
+        return finish({ ok: false, error: "UNKNOWN" });
     }
     static get(url, opts) {
         return this.request({ ...(opts || {}), method: "GET", url });

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

@@ -20,6 +20,11 @@ export declare class Monitor extends BaseEndpoint {
     changeLogLevel(req: HTTPRequestVO): Promise<TransferPacketVO>;
     logs(req: HTTPRequestVO): Promise<TransferPacketVO>;
     netlog(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    outgoingNetlog(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    sysinfo(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    procinfo(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    httpstats(req: HTTPRequestVO): Promise<TransferPacketVO>;
+    inventory(req: HTTPRequestVO): Promise<TransferPacketVO>;
     metrics(req: HTTPRequestVO): Promise<TransferPacketVO>;
     connections(req: HTTPRequestVO): Promise<TransferPacketVO>;
     db(req: HTTPRequestVO): Promise<TransferPacketVO>;

package/dist/apiServer/monitor/Monitor.js

@@ -7,6 +7,7 @@ exports.Monitor = exports.S_MONITOR_REGISTRATE_ACTION = void 0;
 const badmfck_signal_1 = require("badmfck-signal");
 const APIService_1 = require("../APIService");
 const BaseEndpoint_1 = require("../BaseEndpoint");
+const BaseService_1 = require("../BaseService");
 const LogService_1 = require("../LogService");
 const crypto_1 = __importDefault(require("crypto"));
 const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
@@ -15,6 +16,8 @@ const path_1 = __importDefault(require("path"));
 const Http_1 = require("../http/Http");
 const MonitorService_1 = require("../MonitorService");
 const DBService_1 = require("../DBService");
+const SystemInfo_1 = require("./SystemInfo");
+const ProcessMonitor_1 = require("./ProcessMonitor");
 exports.S_MONITOR_REGISTRATE_ACTION = new badmfck_signal_1.Signal();
 const logMap = {
     ALL: 10,
@@ -39,6 +42,11 @@ 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: "outgoingnetlog", handler: this.outgoingNetlog },
+            { ignoreInterceptor: true, endpoint: "sysinfo", handler: this.sysinfo },
+            { ignoreInterceptor: true, endpoint: "procinfo", handler: this.procinfo },
+            { ignoreInterceptor: true, endpoint: "inventory", handler: this.inventory },
+            { ignoreInterceptor: true, endpoint: "httpstats", handler: this.httpstats },
             { ignoreInterceptor: true, endpoint: "metrics", handler: this.metrics, validationModel: {
                     range: "",
                     $__range_values: ["week", "day", "hour"]
@@ -120,6 +128,48 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
         const log = await APIService_1.REQ_HTTP_LOG.request(req.data);
         return { data: log };
     }
+    async outgoingNetlog(req) {
+        await this.checkAuthentication(req);
+        return { data: Http_1.Http.getOutgoingLogSnapshot() };
+    }
+    async sysinfo(req) {
+        await this.checkAuthentication(req);
+        return { data: await (0, SystemInfo_1.collectSystemInfo)() };
+    }
+    async procinfo(req) {
+        await this.checkAuthentication(req);
+        return { data: await ProcessMonitor_1.ProcessMonitor.getSnapshot() };
+    }
+    async httpstats(req) {
+        await this.checkAuthentication(req);
+        return { data: Http_1.Http.getHttpStats() };
+    }
+    async inventory(req) {
+        await this.checkAuthentication(req);
+        const now = Date.now();
+        const services = BaseService_1.BaseService.allInstances.map(s => ({
+            className: s.constructor.name,
+            name: s.getName(),
+            initialized: s.initializedAt !== null,
+            createdAt: s.createdAt,
+            initializedAt: s.initializedAt,
+            applicationReadyAt: s.applicationReadyAt,
+            uptimeSec: s.initializedAt ? Math.round((now - s.initializedAt) / 1000) : null,
+        }));
+        const endpoints = BaseEndpoint_1.BaseEndpoint.allInstances.map(e => e.getInventory());
+        return {
+            data: {
+                services,
+                endpoints,
+                counts: {
+                    services: services.length,
+                    endpoints: endpoints.length,
+                    totalHandlers: endpoints.reduce((sum, e) => sum + e.handlerCount, 0),
+                },
+                entrypoint: BaseEndpoint_1.BaseEndpoint.getEntryPoint(),
+            }
+        };
+    }
     async metrics(req) {
         await this.checkAuthentication(req);
         const result = await MonitorService_1.REQ_STAT.request(req.data);

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

@@ -0,0 +1,117 @@
+/// <reference types="node" />
+export declare class ProcessMonitor {
+    private static _inited;
+    private static _eld;
+    private static _gcObserver;
+    private static _gc;
+    private static _prevCpu;
+    private static _prevCpuAt;
+    private static _cpuPct;
+    private static _eluPrev;
+    private static _elu;
+    private static _processStartedAt;
+    static init(): void;
+    private static _sampleCpu;
+    private static _sampleELU;
+    private static _mapGcKind;
+    static getSnapshot(): Promise<{
+        identity: {
+            pid: number;
+            ppid: number;
+            title: string;
+            argv: string[];
+            execPath: string;
+            cwd: string;
+            nodeVersion: string;
+            v8Version: string;
+            platform: NodeJS.Platform;
+            arch: NodeJS.Architecture;
+            hostname: string;
+            user: {
+                uid: number;
+                gid: number;
+            } | null;
+            startedAtUnix: number;
+            uptimeSec: number;
+            availableParallelism: number;
+        };
+        memory: {
+            rss: number;
+            heapTotal: number;
+            heapUsed: number;
+            external: number;
+            arrayBuffers: any;
+            heap: {
+                sizeLimit: number;
+                usedHeap: number;
+                totalAvailable: number;
+                totalPhysical: number;
+                mallocedMemory: number;
+                peakMallocedMemory: number;
+                numberOfNativeContexts: number;
+                numberOfDetachedContexts: number;
+            };
+            heapSpaces: {
+                name: string;
+                size: number;
+                used: number;
+                available: number;
+                physical: number;
+            }[];
+            procStatus: Record<string, number> | null;
+        };
+        cpu: {
+            userPct: number;
+            systemPct: number;
+            userMicros: number;
+            systemMicros: number;
+            resource: any;
+        };
+        eventLoop: {
+            minMs: number;
+            maxMs: number;
+            meanMs: number;
+            stddevMs: number;
+            p50Ms: number;
+            p90Ms: number;
+            p99Ms: number;
+            utilizationPct: number;
+            activeHandles: number;
+            activeRequests: number;
+            spotLagMs: number;
+        } | null;
+        gc: {
+            totalCount: number;
+            totalTimeMs: number;
+            maxPauseMs: number;
+            byKind: Record<string, {
+                count: number;
+                timeMs: number;
+            }>;
+            lastPauses: {
+                kind: string;
+                ms: number;
+                timestamp: number;
+            }[];
+        };
+        fileDescriptors: {
+            open: number | null;
+            limitSoft: number | null;
+            limitHard: number | null;
+        };
+        io: Record<string, number> | null;
+        limits: Record<string, {
+            soft: string;
+            hard: string;
+            unit: string;
+        }> | null;
+    }>;
+    private static _readProcStatus;
+    private static _readProcIo;
+    private static _readProcLimits;
+    private static _countFds;
+    private static _parseLimitValue;
+    private static _toMsFinite;
+    private static _safePercentileMs;
+    private static _safeCount;
+}