badmfck-api-server 4.1.26 → 4.1.28

package/dist/apiServer/BaseEndpoint.d.ts

@@ -37,6 +37,7 @@ export interface IEndpointHandler {
     resultModel?: any;
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
+    static allInstances: BaseEndpoint[];
     private inializedEndpointNames;
     description: string;
     endpoints?: IEndpointHandler[];
@@ -44,6 +45,8 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     ignoreInDocumentation: boolean;
     private static entrypoint;
     endpoint: string;
+    createdAt: number;
+    initializedAt: number | null;
     protected streamOptions: Record<string, any>;
     static setEntryPoint: (ep: string) => void;
     static getEntryPoint: () => string;
@@ -51,6 +54,29 @@ export declare class BaseEndpoint implements IBaseEndpoint {
     registerEndpoints(endpoints: IEndpointHandler[]): void;
     init(): Promise<void>;
     getInitalizedEndpointNames(): String[];
+    getInventory(): {
+        className: string;
+        basePath: string;
+        ignoreHttpLogging: boolean;
+        ignoreInDocumentation: boolean;
+        description: string;
+        createdAt: number;
+        initializedAt: number | null;
+        handlerCount: number;
+        handlers: {
+            path: string;
+            methods: string[];
+            ignoreInterceptor: boolean;
+            ignoreInDocumentation: boolean;
+            ignoreHttpLogging: boolean;
+            independed: boolean;
+            asStream: boolean;
+            hasValidationModel: boolean;
+            hasResultModel: boolean;
+            description?: string | undefined;
+            title?: string | undefined;
+        }[];
+    };
     __precheck(req: HTTPRequestVO): Promise<TransferPacketVO<any> | null>;
     __execute(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
     protected validateStructure(structure: any, req: HTTPRequestVO): Promise<void>;

package/dist/apiServer/BaseEndpoint.js

@@ -10,6 +10,7 @@ const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
 const stream_1 = require("stream");
 const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"];
 class BaseEndpoint {
+    static allInstances = [];
     inializedEndpointNames = [];
     description = "no description";
     endpoints;
@@ -17,6 +18,8 @@ class BaseEndpoint {
     ignoreInDocumentation = false;
     static entrypoint = "/";
     endpoint = "";
+    createdAt = Date.now();
+    initializedAt = null;
     streamOptions = {};
     static setEntryPoint = (ep) => {
         this.entrypoint = ep;
@@ -35,6 +38,7 @@ class BaseEndpoint {
         if (!endpoint.endsWith("/"))
             endpoint = endpoint + "/";
         this.endpoint = endpoint;
+        BaseEndpoint.allInstances.push(this);
     }
     registerEndpoints(endpoints) {
         for (let i of endpoints) {
@@ -63,11 +67,65 @@ class BaseEndpoint {
             (0, LogService_1.logInfo)("${BaseEndpoint.js}", "endpoint: " + i.endpoint + " initalized, ignoreInterceptor: " + (i.ignoreInterceptor ?? "false"));
             this.inializedEndpointNames.push(i.endpoint + " ignore interceptor: " + (i.ignoreInterceptor ?? "false"));
         }
+        this.initializedAt = Date.now();
     }
     ;
     getInitalizedEndpointNames() {
         return this.inializedEndpointNames;
     }
+    getInventory() {
+        const handlers = [];
+        for (const i of this.endpoints ?? []) {
+            let methods = [];
+            let asStream = i.asStream === true;
+            let hasVm = i.validationModel !== undefined;
+            let hasRm = i.resultModel !== undefined;
+            if (typeof i.handler === "function") {
+                methods = ["ANY"];
+            }
+            else if (i.handler && typeof i.handler === "object") {
+                for (const key of Object.keys(i.handler)) {
+                    const h = i.handler[key];
+                    if (typeof h === "function") {
+                        methods.push(key);
+                    }
+                    else if (h && typeof h === "object" && typeof h.controller === "function") {
+                        methods.push(key);
+                        if (h.asStream)
+                            asStream = true;
+                        if (h.validationModel !== undefined)
+                            hasVm = true;
+                        if (h.resultModel !== undefined)
+                            hasRm = true;
+                    }
+                }
+            }
+            handlers.push({
+                path: (BaseEndpoint.entrypoint + i.endpoint).replaceAll("//", "/"),
+                methods,
+                ignoreInterceptor: i.ignoreInterceptor === true,
+                ignoreInDocumentation: i.ignoreInDocumentation === true,
+                ignoreHttpLogging: i.ignoreHttpLogging === true,
+                independed: i.independed === true,
+                asStream,
+                hasValidationModel: hasVm,
+                hasResultModel: hasRm,
+                description: i.description,
+                title: i.title,
+            });
+        }
+        return {
+            className: this.constructor.name,
+            basePath: this.endpoint,
+            ignoreHttpLogging: this.ignoreHttpLogging,
+            ignoreInDocumentation: this.ignoreInDocumentation,
+            description: this.description,
+            createdAt: this.createdAt,
+            initializedAt: this.initializedAt,
+            handlerCount: handlers.length,
+            handlers,
+        };
+    }
     async __precheck(req) { return null; }
     async __execute(req) {
         if (this.endpoints && this.endpoints.length > 0) {

package/dist/apiServer/BaseService.d.ts

@@ -4,7 +4,11 @@ export interface IBaseService {
     getName: () => string;
 }
 export declare class BaseService implements IBaseService {
+    static allInstances: BaseService[];
     protected name: string;
+    createdAt: number;
+    initializedAt: number | null;
+    applicationReadyAt: number | null;
     constructor(name: string);
     init(): Promise<void>;
     finishService(): Promise<void>;

package/dist/apiServer/BaseService.js

@@ -11,14 +11,20 @@ process.on('SIGTERM', async () => {
     process.exit(0);
 });
 class BaseService {
+    static allInstances = [];
     name = "BaseService";
+    createdAt = Date.now();
+    initializedAt = null;
+    applicationReadyAt = null;
     constructor(name) {
         this.name = name;
         this.finishService = this.finishService.bind(this);
+        BaseService.allInstances.push(this);
     }
     async init() {
         console.log("Service: " + this.name + " initialized");
         finalize.push(this.finishService);
+        this.initializedAt = Date.now();
     }
     async finishService() {
         console.log("finishService -> " + (this.name ?? "no-name"));
@@ -26,6 +32,8 @@ class BaseService {
     getName() {
         return this.name;
     }
-    applicationReady() { }
+    applicationReady() {
+        this.applicationReadyAt = Date.now();
+    }
 }
 exports.BaseService = BaseService;

package/dist/apiServer/LogService.d.ts

@@ -62,4 +62,9 @@ export declare class LogService extends BaseService {
     createDate(d?: Date): string;
     leadZero(num: number): string;
     createText(data: any, level: LOG_LEVEL): string;
+    private static readonly SANITIZERS;
+    static sanitize(text: string): string;
+    private static readonly PAN_CANDIDATE_REGEX;
+    private static isLuhnValid;
+    static maskPAN(text: string): string;
 }

package/dist/apiServer/LogService.js

@@ -244,7 +244,54 @@ class LogService extends BaseService_1.BaseService {
         }
         if (res.length > this.options.textLimit && level === LOG_LEVEL.INFO)
             res = res.substring(0, this.options.textLimit) + "... (total: " + res.length + ")";
+        res = LogService.sanitize(res);
         return res;
     }
+    static SANITIZERS = [
+        [/-----BEGIN [A-Z0-9 ]+-----[\s\S]+?-----END [A-Z0-9 ]+-----/g, "<REDACTED PEM>"],
+        [/eyJ[A-Za-z0-9_-]{5,}\.eyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]+/g, "<REDACTED JWT>"],
+        [/(Bearer|Basic|Digest)\s+[A-Za-z0-9\-._~+\/=]+/gi, "$1 <REDACTED>"],
+        [/%B\d{13,19}\^[^?]{2,50}\^\d{4,}[^?]*\?/g, "<REDACTED TRACK1>"],
+        [/;\d{13,19}=\d{4,}[^?]*\?/g, "<REDACTED TRACK2>"],
+        [/("(?:password|passwd|pwd|secret|api[_-]?key|api[_-]?secret|client[_-]?secret|access[_-]?key|private[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|token|authorization|cookie|set[_-]?cookie|session[_-]?id|sess[_-]?id|sid|cvv2?|cvc2?|cvn|cav2?|cid|security[_-]?code|card[_-]?verification[_-]?(?:value|code)?|pin|pin[_-]?block|encrypted[_-]?pin|iso[_-]?9564|exp|expiry|expiration|expiration[_-]?date|exp[_-]?date|exp[_-]?month|exp[_-]?year|cardholder[_-]?name|holder[_-]?name|card[_-]?holder)"\s*:\s*)"[^"]*"/gi, '$1"<REDACTED>"'],
+        [/("(?:cvv2?|cvc2?|pin|exp[_-]?month|exp[_-]?year|service[_-]?code)"\s*:\s*)(-?\d+)/gi, '$1"<REDACTED>"'],
+    ];
+    static sanitize(text) {
+        if (!text || text.length < 3)
+            return text;
+        let out = text;
+        for (const [re, repl] of LogService.SANITIZERS)
+            out = out.replace(re, repl);
+        return LogService.maskPAN(out);
+    }
+    static PAN_CANDIDATE_REGEX = /(?<!\d)(?:\d[ -]?){12,18}\d(?!\d)/g;
+    static isLuhnValid(digits) {
+        if (digits.length < 13 || digits.length > 19)
+            return false;
+        let sum = 0;
+        let alt = false;
+        for (let i = digits.length - 1; i >= 0; i--) {
+            const d = digits.charCodeAt(i) - 48;
+            if (d < 0 || d > 9)
+                return false;
+            let x = d;
+            if (alt) {
+                x *= 2;
+                if (x > 9)
+                    x -= 9;
+            }
+            sum += x;
+            alt = !alt;
+        }
+        return sum % 10 === 0;
+    }
+    static maskPAN(text) {
+        if (!text || text.length < 13)
+            return text;
+        return text.replace(LogService.PAN_CANDIDATE_REGEX, (match) => {
+            const digits = match.replace(/\D/g, "");
+            return LogService.isLuhnValid(digits) ? "xxxx...xxxx" : match;
+        });
+    }
 }
 exports.LogService = LogService;

package/dist/apiServer/external/MicroserviceClient.js

@@ -90,14 +90,14 @@ class MicroserviceClient extends BaseService_1.BaseService {
                     await TimeframeService_1.TimeframeService.wait(attemptTimeout * attempt);
                     continue;
                 }
-                return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, details: "Network connection lost after multiple retries, attempts: " + attempt };
+                return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, stack: [this.options.host, req], details: "Network connection lost after multiple retries, attempts: " + attempt };
             }
             if (!resp.ok) {
                 console.log(`Microservice call error response:`, resp);
                 const remoteError = resp.error?.error;
                 if (DefaultErrors_1.ErrorUtils.isError(remoteError))
                     return remoteError;
-                return { ...DefaultErrors_1.default.BAD_REQUEST, stack: [resp.error], details: resp.details };
+                return { ...DefaultErrors_1.default.BAD_REQUEST, stack: [this.options.host, req, resp.error], details: resp.details };
             }
             const body = resp.data;
             const isAccepted = body?.error?.code === DefaultErrors_1.default.ACCEPTED.code || body?.code === DefaultErrors_1.default.ACCEPTED.code;
@@ -106,14 +106,14 @@ class MicroserviceClient extends BaseService_1.BaseService {
                     await TimeframeService_1.TimeframeService.wait(attemptTimeout * attempt);
                     continue;
                 }
-                return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, details: "Microservice processing timeout, attempts: " + attempt };
+                return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, stack: [this.options.host, req], details: "Microservice processing timeout, attempts: " + attempt };
             }
             if (body && typeof body === "object") {
                 return "error" in body ? body.error : (body.data ?? null);
             }
             return body ?? null;
         }
-        return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, details: "Unknown polling error" };
+        return { ...DefaultErrors_1.default.EXTERNAL_SERVICE_ERROR, stack: [this.options.host, req], details: "Unknown polling error" };
     }
 }
 exports.MicroserviceClient = MicroserviceClient;

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

@@ -26,6 +26,47 @@ export type THttpOutgoingLogItem = {
     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;
@@ -90,6 +131,21 @@ export declare class Http {
     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

@@ -118,10 +118,149 @@ class Http {
             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;
@@ -299,8 +438,11 @@ 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._pushOutgoingLog({
+            Http._decInFlight(host);
+            const entry = Http._pushOutgoingLog({
                 created: overallStarted,
                 time: Date.now() - overallStarted,
                 method: opts.method,
@@ -312,6 +454,9 @@ class Http {
                 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++) {

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

@@ -23,6 +23,8 @@ export declare class Monitor extends BaseEndpoint {
     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"));
@@ -44,6 +45,8 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
             { 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"]
@@ -137,6 +140,36 @@ class Monitor extends BaseEndpoint_1.BaseEndpoint {
         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);