badmfck-api-server 4.0.98 → 4.1.1

package/dist/apiServer/APIService.js

@@ -97,7 +97,7 @@ async function Initializer(services) {
 }
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
-    version = "4.0.98";
+    version = "4.1.01";
     options;
     monitor = null;
     started = new Date();
@@ -420,6 +420,10 @@ class APIService extends BaseService_1.BaseService {
         });
     }
     addNetlog(data, req, created, time) {
+        if (time === 0) {
+            time = +new Date() - created;
+            created = +new Date();
+        }
         const logItem = {
             id: nextLogID++,
             created: created,
@@ -447,7 +451,7 @@ class APIService extends BaseService_1.BaseService {
                 this.addNetlog(data, req, requestTime, 0);
             return;
         }
-        MonitorService_1.S_STAT_REGISTRATE_REQUEST.invoke(data);
+        MonitorService_1.S_STAT_REGISTRATE_REQUEST.invoke({ ...data, endpoint: data.endpoint ?? endpoint });
         if (this.options.postproducer) {
             try {
                 data = await this.options.postproducer(req, res, data, requestTime, endpoint);
@@ -511,8 +515,6 @@ class APIService extends BaseService_1.BaseService {
                     else {
                         res.send(data);
                         (0, LogService_1.logAPI)(this.checkDataLength(data));
-                        if (data.error)
-                            (0, LogService_1.logError)(data.error.message);
                     }
                 }
             }

package/dist/apiServer/DBService.d.ts

@@ -1,4 +1,4 @@
-import Signal, { Req } from "badmfck-signal";
+import { Req } from "badmfck-signal";
 import { BaseService } from "./BaseService";
 import { IDBAdapter } from "./db/IDBAdapter";
 export interface IDBQueryField {
@@ -76,22 +76,23 @@ export interface DBAdapterOptions {
     maxQueryTimeout?: number;
     debug?: boolean;
 }
-type ILongQuery = {
-    query: string;
-    started_at: number;
-    finished_at: number;
-    execution: number;
-};
-type IQueriesStat = {
-    failed: number;
-    success: number;
-    failedQueries: string[];
-};
 export interface IPoolStatus {
     lastSuccessQueryTime: string;
     poolConnections: number;
     acquiredPoolConnections: number;
 }
+export interface IDBStatFrame {
+    transactionsCount: number;
+    averageQueryTime: number;
+    totalQueries: number;
+    maxQueryTime: number;
+    minQueryTime: number;
+    failedQueries: number;
+    longestQueries: {
+        query: string;
+        execution: number;
+    }[];
+}
 export declare const REQ_DB: Req<IDBQuery, IDBResult>;
 export declare const REQ_DBX: Req<IDBBulkQuery, IDBResult[]>;
 export declare const REQ_DB_TBEGIN: Req<{
@@ -105,32 +106,24 @@ export declare const REQ_DB_TROLLBACK: Req<{
     dbid: string;
     trxid: number;
 }, IDBResult>;
-export declare const S_DB_STAT: Signal<{
-    dbid: string;
-    stat: {
-        queriesStat: {
-            hour: string;
-            stat: IQueriesStat;
-        };
-        poolStatus: IPoolStatus;
-        longQueries: ILongQuery[];
-    };
-}>;
 export declare class DBService extends BaseService {
     static allInstances: DBService[];
-    longQueries: ILongQuery[];
-    queriesStat: {
-        hour: string;
-        stat: IQueriesStat;
-    };
     options: IDBSericeOptions;
     adapter: IDBAdapter | null;
     constructor(options: IDBSericeOptions);
     init(): Promise<void>;
     static escape(id: string, value: any): string;
     getAdapter(dbid?: string | null): IDBAdapter | IDBError;
-    reportQuery(result: IDBResult, req: IDBQuery): Promise<void>;
+    static healthcheck(range?: "hour" | "day" | "week"): {
+        id: string;
+        host: string;
+        port: number;
+        poolStatus: IPoolStatus | null;
+        stat: (IDBStatFrame & {
+            slot: number;
+        })[] | null;
+    }[];
+    private static aggregateStat;
     finishService(): Promise<void>;
     createMysqlDatabase(): Promise<void>;
 }
-export {};

package/dist/apiServer/DBService.js

@@ -1,44 +1,17 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBService = exports.S_DB_STAT = exports.REQ_DB_TROLLBACK = exports.REQ_DB_TCOMMIT = exports.REQ_DB_TBEGIN = exports.REQ_DBX = exports.REQ_DB = void 0;
-const badmfck_signal_1 = __importStar(require("badmfck-signal"));
+exports.DBService = exports.REQ_DB_TROLLBACK = exports.REQ_DB_TCOMMIT = exports.REQ_DB_TBEGIN = exports.REQ_DBX = exports.REQ_DB = void 0;
+const badmfck_signal_1 = require("badmfck-signal");
 const BaseService_1 = require("./BaseService");
 const MysqlAdapter_1 = require("./db/MysqlAdapter");
-const LogService_1 = require("./LogService");
 const PostgresAdapter_1 = require("./db/PostgresAdapter");
 exports.REQ_DB = new badmfck_signal_1.Req(undefined, "REQ_DB");
 exports.REQ_DBX = new badmfck_signal_1.Req(undefined, "REQ_DBX");
 exports.REQ_DB_TBEGIN = new badmfck_signal_1.Req(undefined, "REQ_DB_TBEGIN");
 exports.REQ_DB_TCOMMIT = new badmfck_signal_1.Req(undefined, "REQ_DB_TCOMMIT");
 exports.REQ_DB_TROLLBACK = new badmfck_signal_1.Req(undefined, "REQ_DB_TROLLBACK");
-exports.S_DB_STAT = new badmfck_signal_1.default();
 class DBService extends BaseService_1.BaseService {
     static allInstances = [];
-    longQueries = [];
-    queriesStat = { hour: "00", stat: { failed: 0, success: 0, failedQueries: [] } };
     options;
     adapter = null;
     constructor(options) {
@@ -51,27 +24,6 @@ class DBService extends BaseService_1.BaseService {
             }
         }
         DBService.allInstances.push(this);
-        setInterval(() => {
-            (0, LogService_1.logDB)("Queries (" + options.id + ") at: " + new Date().toDateString() + " " + this.queriesStat.hour + ":--\n" + "success: " + this.queriesStat.stat.success + "\nfailed: " + this.queriesStat.stat.failed);
-            let poolStatus = {
-                lastSuccessQueryTime: "-1",
-                poolConnections: -1,
-                acquiredPoolConnections: -1
-            };
-            if (this.adapter) {
-                poolStatus = this.adapter.poolStatus();
-                (0, LogService_1.logDB)("Pool status (" + options.id + ") at: " + new Date().toDateString() + " " + new Date().toTimeString() + "\n LSQT: " + poolStatus.lastSuccessQueryTime + "\nCONN: " + poolStatus.poolConnections + "\nACONN: " + poolStatus.acquiredPoolConnections);
-            }
-            (0, LogService_1.logDB)(`Long queries ${options.id}\n${this.longQueries.map(val => `exec: ${val.execution} at: ${new Date(val.started_at).toISOString()}, ${val.query}`).join("\n")}`);
-            exports.S_DB_STAT.invoke({
-                dbid: options.id,
-                stat: {
-                    queriesStat: this.queriesStat,
-                    poolStatus: poolStatus,
-                    longQueries: this.longQueries
-                }
-            });
-        }, 1000 * 60 * 1);
     }
     async init() {
         super.init();
@@ -84,17 +36,11 @@ class DBService extends BaseService_1.BaseService {
         exports.REQ_DBX.listener = async (req) => {
             const executionStartTime = Date.now();
             if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter) {
-                const result = await DBService.allInstances[0].adapter.bulk(req);
-                for (let i = 0; i < result.length; i++)
-                    this.reportQuery(result[i], req.bulk[i]);
-                return result;
+                return await DBService.allInstances[0].adapter.bulk(req);
             }
             for (let i of DBService.allInstances) {
                 if (i.options.id === req.dbid && i.adapter) {
-                    const result = await i.adapter.bulk(req);
-                    for (let i = 0; i < result.length; i++)
-                        this.reportQuery(result[i], req.bulk[i]);
-                    return result;
+                    return await i.adapter.bulk(req);
                 }
             }
             const error = {
@@ -208,15 +154,11 @@ class DBService extends BaseService_1.BaseService {
                 req.fields = JSON.parse(JSON.stringify(req.fields));
             const executionStartTime = Date.now();
             if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter) {
-                const result = await DBService.allInstances[0].adapter.query(req);
-                this.reportQuery(result, req);
-                return result;
+                return await DBService.allInstances[0].adapter.query(req);
             }
             for (let i of DBService.allInstances) {
                 if (i.options.id === req.dbid && i.adapter) {
-                    const result = await i.adapter.query(req);
-                    this.reportQuery(result, req);
-                    return result;
+                    return await i.adapter.query(req);
                 }
             }
             const error = {
@@ -234,7 +176,6 @@ class DBService extends BaseService_1.BaseService {
                     finished_at: Date.now()
                 }
             };
-            this.reportQuery(errorResult, req);
             if (req.throwable)
                 throw error;
             return errorResult;
@@ -283,33 +224,61 @@ class DBService extends BaseService_1.BaseService {
         };
         return error;
     }
-    async reportQuery(result, req) {
-        const hour = new Date().getHours().toString().padStart(2, "0");
-        if (this.queriesStat.hour !== hour) {
-            this.queriesStat.hour = hour;
-            this.queriesStat.stat = { failed: 0, success: 0, failedQueries: [] };
-        }
-        if (result.error) {
-            this.queriesStat.stat.failed++;
-            this.queriesStat.stat.failedQueries.push(req.query);
-        }
-        else
-            this.queriesStat.stat.success++;
-        const execTime = result.execution.finished_at - result.execution.started_at;
-        if (execTime && execTime > 0) {
-            const minLong = this.longQueries.length < 20 || execTime > this.longQueries[0].execution;
-            if (minLong) {
-                this.longQueries.push({
-                    execution: execTime,
-                    query: req.query,
-                    started_at: result.execution.started_at,
-                    finished_at: result.execution.finished_at
-                });
+    static healthcheck(range = "hour") {
+        return DBService.allInstances.map(i => {
+            const frames = i.adapter?.stat();
+            const stat = frames ? DBService.aggregateStat(frames, range) : null;
+            return {
+                id: i.options.id,
+                host: i.options.connection.host,
+                port: i.options.connection.port,
+                poolStatus: i.adapter?.poolStatus() ?? null,
+                stat
+            };
+        });
+    }
+    static aggregateStat(frames, range) {
+        const steps = { hour: 1, day: 10, week: 30 };
+        const limits = { hour: 60, day: 1440, week: 7200 };
+        const step = steps[range];
+        const limit = limits[range];
+        const sorted = Array.from(frames.entries()).sort(([a], [b]) => a - b);
+        const limited = sorted.slice(-limit);
+        const result = [];
+        for (let i = 0; i < limited.length; i += step) {
+            const chunk = limited.slice(i, i + step);
+            let totalQueries = 0;
+            let failedQueries = 0;
+            let transactionsCount = 0;
+            let weightedAvgSum = 0;
+            let maxQueryTime = 0;
+            let minQueryTime = Infinity;
+            const merged = [];
+            for (const [, frame] of chunk) {
+                totalQueries += frame.totalQueries;
+                failedQueries += frame.failedQueries;
+                transactionsCount += frame.transactionsCount;
+                weightedAvgSum += frame.averageQueryTime * frame.totalQueries;
+                if (frame.maxQueryTime > maxQueryTime)
+                    maxQueryTime = frame.maxQueryTime;
+                if (frame.totalQueries > 0 && frame.minQueryTime < minQueryTime)
+                    minQueryTime = frame.minQueryTime;
+                if (frame.longestQueries.length)
+                    merged.push(...frame.longestQueries);
             }
-            this.longQueries.sort((a, b) => a.execution - b.execution);
-            if (this.longQueries.length > 20)
-                this.longQueries = this.longQueries.slice(-20);
+            merged.sort((a, b) => b.execution - a.execution);
+            result.push({
+                slot: chunk[0][0],
+                transactionsCount,
+                totalQueries,
+                failedQueries,
+                averageQueryTime: totalQueries > 0 ? weightedAvgSum / totalQueries : 0,
+                maxQueryTime,
+                minQueryTime: minQueryTime === Infinity ? 0 : minQueryTime,
+                longestQueries: merged.slice(0, 5)
+            });
         }
+        return result;
     }
     async finishService() {
         await this.adapter?.finish();

package/dist/apiServer/MonitorService.d.ts

@@ -16,6 +16,10 @@ 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_SQL_REQUEST: Signal<{
+    success: boolean;
+    query: string;
+}>;
 export declare const REQ_STAT: Req<{
     range: "week" | "day" | "hour";
 }, IStat[]>;
@@ -32,6 +36,8 @@ type IMonitorSlot = {
     successEp: Record<string, number>;
     failEp: Record<string, number>;
     http: Record<string, number>;
+    success_sql: Record<string, number>;
+    fail_sql: Record<string, number>;
 };
 export declare class MonitorService extends BaseService {
     slots: Map<number, Map<number, IMonitorSlot>>;
@@ -47,7 +53,12 @@ export declare class MonitorService extends BaseService {
     private slotToTimestamp;
     onStatRegistrate(data: TransferPacketVO): void;
     collectUsage(): Promise<void>;
+    private static MAX_SLOT_KEYS;
+    static normalizeQuery(query: string): string;
+    static normalizeUrl(url: string): string;
+    private bumpCappedKey;
     private onHttpRequestRegistrate;
+    private onSQLRequestRegistrate;
     private getSlot;
 }
 export {};

package/dist/apiServer/MonitorService.js

@@ -26,7 +26,7 @@ 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_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 = 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;
 const badmfck_signal_1 = __importStar(require("badmfck-signal"));
 const BaseService_1 = require("./BaseService");
 const YYYYMMDDHH_1 = require("./helper/YYYYMMDDHH");
@@ -35,6 +35,7 @@ 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_SQL_REQUEST = new badmfck_signal_1.default();
 exports.REQ_STAT = new badmfck_signal_1.Req(undefined, "REQ_STAT");
 class MonitorService extends BaseService_1.BaseService {
     slots = new Map();
@@ -49,6 +50,7 @@ class MonitorService extends BaseService_1.BaseService {
         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_SQL_REQUEST.subscribe((data) => this.onSQLRequestRegistrate(data));
         exports.S_STAT_REGISTRATE_REQUEST.subscribe((data) => this.onStatRegistrate(data));
     }
     async getEPStat(req) {
@@ -78,7 +80,9 @@ class MonitorService extends BaseService_1.BaseService {
                 memory: { rss: 0, heapUsed: 0, heapTotal: 0, external: 0 },
                 successEp: {},
                 failEp: {},
-                http: {}
+                http: {},
+                success_sql: {},
+                fail_sql: {}
             };
             chunk.forEach(s => {
                 agg.cpu += s.cpu;
@@ -93,6 +97,12 @@ class MonitorService extends BaseService_1.BaseService {
                 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;
+                }
             });
             const len = chunk.length;
             agg.cpu = Number((agg.cpu / len).toFixed(2));
@@ -141,11 +151,51 @@ class MonitorService extends BaseService_1.BaseService {
             external: Math.round(mem.external / 1024 / 1024),
         };
     }
+    static MAX_SLOT_KEYS = 100;
+    static normalizeQuery(query) {
+        const normalized = query
+            .replace(/'(?:\\.|''|[^'])*'/g, "?")
+            .replace(/"(?:\\.|""|[^"])*"/g, "?")
+            .replace(/\b\d+(?:\.\d+)?\b/g, "?")
+            .replace(/\(\s*\?(?:\s*,\s*\?)+\s*\)/g, "(?)")
+            .replace(/\s+/g, " ")
+            .trim();
+        return normalized.length > 300 ? normalized.substring(0, 300) : normalized;
+    }
+    static normalizeUrl(url) {
+        const q = url.indexOf("?");
+        const h = url.indexOf("#");
+        let end = url.length;
+        if (q >= 0)
+            end = Math.min(end, q);
+        if (h >= 0)
+            end = Math.min(end, h);
+        const path = url.substring(0, end);
+        return path.length > 200 ? path.substring(0, 200) : path;
+    }
+    bumpCappedKey(record, key) {
+        if (key in record) {
+            record[key]++;
+            return;
+        }
+        if (Object.keys(record).length >= MonitorService.MAX_SLOT_KEYS) {
+            record["__other__"] = (record["__other__"] || 0) + 1;
+            return;
+        }
+        record[key] = 1;
+    }
     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;
+        this.bumpCappedKey(slot.http, MonitorService.normalizeUrl(data.url));
+    }
+    onSQLRequestRegistrate(data) {
+        const date = new Date();
+        const yyyymmddhhmm = parseInt((0, YYYYMMDDHH_1.YYYYMMDDHH)(date, "yyyymmddhhmm"));
+        const slot = this.getSlot(yyyymmddhhmm);
+        const key = MonitorService.normalizeQuery(data.query);
+        this.bumpCappedKey(data.success ? slot.success_sql : slot.fail_sql, key);
     }
     getSlot(yyyymmddhhii) {
         const yyymmdd = Math.floor(yyyymmddhhii / 100);
@@ -172,7 +222,9 @@ class MonitorService extends BaseService_1.BaseService {
                 },
                 successEp: {},
                 failEp: {},
-                http: {}
+                http: {},
+                success_sql: {},
+                fail_sql: {}
             };
             daySlots.set(yyyymmddhhii, slot);
         }

package/dist/apiServer/db/IDBAdapter.d.ts

@@ -1,4 +1,4 @@
-import { IDBBulkQuery, IDBQuery, IDBResult, IPoolStatus } from "../DBService";
+import { IDBBulkQuery, IDBQuery, IDBResult, IDBStatFrame, IPoolStatus } from "../DBService";
 export interface IDBAdapter {
     init(): Promise<void>;
     finish(): Promise<void>;
@@ -10,4 +10,5 @@ export interface IDBAdapter {
     bulk(request: IDBBulkQuery): Promise<IDBResult[]>;
     poolStatus(): IPoolStatus;
     escape(value: string): string;
+    stat(): Map<number, IDBStatFrame>;
 }

package/dist/apiServer/db/MysqlAdapter.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { DBAdapterOptions, IDBBulkQuery, IDBError, IDBQuery, IDBQueryField, IDBResult } from "../DBService";
+import { DBAdapterOptions, IDBBulkQuery, IDBError, IDBQuery, IDBQueryField, IDBResult, IDBStatFrame } from "../DBService";
 import { IDBAdapter } from "./IDBAdapter";
 import mysql from 'mysql2/promise';
 import fs from 'fs';
@@ -30,8 +30,14 @@ export declare class MysqlAdapter implements IDBAdapter {
     failReportLastAccessTime: number;
     poolConnections: number;
     acquiredPoolConnections: number;
+    statFrames: Map<number, IDBStatFrame>;
     constructor(options: DBAdapterOptions);
     escape(value: string): string;
+    stat(): Map<number, IDBStatFrame>;
+    private statRetentionMs;
+    private getOrCreateStatSlot;
+    collectStat(query: string, execTime: number, failed: boolean): void;
+    collectTransactionStat(): void;
     init(): Promise<void>;
     poolStatus(): {
         lastSuccessQueryTime: string;

package/dist/apiServer/db/MysqlAdapter.js

@@ -10,6 +10,8 @@ const LogService_1 = require("../LogService");
 const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
 const path_1 = __importDefault(require("path"));
 const crypto_1 = require("crypto");
+const MonitorService_1 = require("../MonitorService");
+const __1 = require("../..");
 class MysqlAdapter {
     options;
     serviceStarted = false;
@@ -28,6 +30,7 @@ class MysqlAdapter {
     failReportLastAccessTime = 0;
     poolConnections = 0;
     acquiredPoolConnections = 0;
+    statFrames = new Map();
     constructor(options) {
         this.options = options;
         if (this.options.host.startsWith("_"))
@@ -42,6 +45,59 @@ class MysqlAdapter {
     escape(value) {
         return promise_1.default.escape(value);
     }
+    stat() {
+        return this.statFrames;
+    }
+    statRetentionMs = 5 * 24 * 60 * 60 * 1000;
+    getOrCreateStatSlot(date = new Date()) {
+        const key = parseInt((0, __1.YYYYMMDDHH)(date, "yyyymmddhhmm"));
+        let slot = this.statFrames.get(key);
+        if (slot)
+            return slot;
+        slot = {
+            transactionsCount: 0,
+            averageQueryTime: 0,
+            totalQueries: 0,
+            maxQueryTime: 0,
+            minQueryTime: 0,
+            failedQueries: 0,
+            longestQueries: []
+        };
+        this.statFrames.set(key, slot);
+        const cutoff = parseInt((0, __1.YYYYMMDDHH)(new Date(date.getTime() - this.statRetentionMs), "yyyymmddhhmm"));
+        for (const k of this.statFrames.keys()) {
+            if (k < cutoff)
+                this.statFrames.delete(k);
+        }
+        return slot;
+    }
+    collectStat(query, execTime, failed) {
+        const slot = this.getOrCreateStatSlot();
+        slot.totalQueries++;
+        if (failed)
+            slot.failedQueries++;
+        slot.averageQueryTime += (execTime - slot.averageQueryTime) / slot.totalQueries;
+        if (slot.totalQueries === 1) {
+            slot.maxQueryTime = execTime;
+            slot.minQueryTime = execTime;
+        }
+        else {
+            if (execTime > slot.maxQueryTime)
+                slot.maxQueryTime = execTime;
+            if (execTime < slot.minQueryTime)
+                slot.minQueryTime = execTime;
+        }
+        const truncated = query.length > 100 ? query.substring(0, 100) : query;
+        if (slot.longestQueries.length < 5 || execTime > slot.longestQueries[slot.longestQueries.length - 1].execution) {
+            slot.longestQueries.push({ query: truncated, execution: execTime });
+            slot.longestQueries.sort((a, b) => b.execution - a.execution);
+            if (slot.longestQueries.length > 5)
+                slot.longestQueries.length = 5;
+        }
+    }
+    collectTransactionStat() {
+        this.getOrCreateStatSlot().transactionsCount++;
+    }
     async init() {
         if (this.options.transactionFailReportDir) {
             try {
@@ -213,6 +269,7 @@ class MysqlAdapter {
         }
         trxRequest.queries.push({ sql: "START TRANSACTION", status: "ok" });
         this.transactions.push(trxRequest);
+        this.collectTransactionStat();
         if (this.options.debug)
             (0, LogService_1.logDB)("Transactions pool: ", this.transactions.map(t => "id:" + t.id + ", queries: " + t.queries.length));
         return {
@@ -410,8 +467,9 @@ class MysqlAdapter {
     async query(request, conn) {
         let executionStartTime = Date.now();
         const query = this.prepareQuery(request);
+        const isPing = query.trim().toLowerCase() === "select 1";
         if (this.options.debug || request.debug) {
-            if (query.toLowerCase().trim().indexOf("select 1") === -1)
+            if (!isPing)
                 (0, LogService_1.logDB)(query);
         }
         if (request.parseQueryOnly) {
@@ -468,17 +526,26 @@ class MysqlAdapter {
                 this.finalizeConnection(conn);
             if (trx)
                 trx.queries.push({ sql: query, status: "ok" });
+            const finishedAt = Date.now();
+            if (!isPing) {
+                MonitorService_1.S_STAT_REGISTRATE_SQL_REQUEST.invoke({ success: true, query });
+                this.collectStat(query, finishedAt - executionStartTime, false);
+            }
             return {
                 data: result[0],
                 error: null,
                 total: total ? total : undefined,
                 execution: {
                     started_at: executionStartTime,
-                    finished_at: Date.now()
+                    finished_at: finishedAt
                 }
             };
         }
         catch (e) {
+            if (!isPing) {
+                MonitorService_1.S_STAT_REGISTRATE_SQL_REQUEST.invoke({ success: false, query });
+                this.collectStat(query, Date.now() - executionStartTime, true);
+            }
             if (!request.transactionID && doCloseConnection)
                 this.finalizeConnection(conn);
             else if (request.transactionID && request.throwable) {

package/dist/apiServer/db/PostgresAdapter.d.ts

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { DBAdapterOptions, IDBQuery, IDBResult, IDBBulkQuery, IPoolStatus } from '../DBService';
+import { DBAdapterOptions, IDBQuery, IDBResult, IDBBulkQuery, IPoolStatus, IDBStatFrame } from '../DBService';
 import { ITransaction } from '../MysqlService';
 import { IDBAdapter } from './IDBAdapter';
 export declare class PostgresAdapter implements IDBAdapter {
@@ -17,7 +17,9 @@ export declare class PostgresAdapter implements IDBAdapter {
     pingInterval: number;
     poolConnections: number;
     acquiredPoolConnections: number;
+    statFrames: Map<number, IDBStatFrame>;
     constructor(options: DBAdapterOptions);
+    stat(): Map<number, IDBStatFrame>;
     escape(value: string): string;
     tBegin?(): Promise<IDBResult>;
     tCommit?(trxid: number): Promise<IDBResult>;

package/dist/apiServer/db/PostgresAdapter.js

@@ -18,9 +18,13 @@ class PostgresAdapter {
     pingInterval = 1000 * 60 * 5;
     poolConnections = 0;
     acquiredPoolConnections = 0;
+    statFrames = new Map();
     constructor(options) {
         this.options = options;
     }
+    stat() {
+        return this.statFrames;
+    }
     escape(value) {
         return value;
     }