badmfck-api-server 3.6.6 → 3.6.8

package/dist/apiServer/APIService.js

@@ -95,7 +95,7 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "3.6.6";
+    version = "3.6.8";
     options;
     monitor = null;
     started = new Date();

package/dist/apiServer/DBService.d.ts

@@ -1,4 +1,4 @@
-import { Req } from "badmfck-signal";
+import Signal, { Req } from "badmfck-signal";
 import { BaseService } from "./BaseService";
 import { IDBAdapter } from "./db/IDBAdapter";
 export interface IDBQueryField {
@@ -48,6 +48,10 @@ export interface IDBError {
 export interface IDBResult {
     data?: any | null;
     error?: IDBError | null;
+    execution: {
+        started_at: number;
+        finished_at: number;
+    };
 }
 export interface IDBSericeOptions {
     id: string;
@@ -64,9 +68,25 @@ export interface DBAdapterOptions {
     queueLimit?: number;
     transactionFailReport?: (trx: any, message: string) => void;
     transactionFailReportDir?: string;
-    naxTransactionWaitTime?: number;
+    maxTransactionWaitTime?: number;
+    maxQueryTimeout?: number;
     debug?: boolean;
 }
+type ILongQuery = {
+    query: string;
+    started_at: number;
+    finished_at: number;
+    execution: number;
+};
+type IQueriesStat = {
+    failed: number;
+    success: number;
+};
+export interface IPoolStatus {
+    lastSuccessQueryTime: string;
+    poolConnections: number;
+    acquiredPoolConnections: number;
+}
 export declare const REQ_DB: Req<IDBQuery, IDBResult>;
 export declare const REQ_DBX: Req<IDBBulkQuery, IDBResult[]>;
 export declare const REQ_DB_TBEGIN: Req<{
@@ -80,13 +100,31 @@ 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>;
     getAdapter(dbid?: string | null): IDBAdapter | IDBError;
+    reportQuery(result: IDBResult, req: IDBQuery): Promise<void>;
     finishService(): Promise<void>;
     createMysqlDatabase(): Promise<void>;
 }
+export {};

package/dist/apiServer/DBService.js

@@ -1,16 +1,43 @@
 "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.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");
+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"));
 const BaseService_1 = require("./BaseService");
 const MysqlAdapter_1 = require("./db/MysqlAdapter");
+const LogService_1 = require("./LogService");
 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_TBEGIN");
 exports.REQ_DB_TROLLBACK = new badmfck_signal_1.Req(undefined, "REQ_DB_TBEGIN");
+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 } };
     options;
     adapter = null;
     constructor(options) {
@@ -23,6 +50,27 @@ 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();
@@ -30,11 +78,20 @@ class DBService extends BaseService_1.BaseService {
             await this.createMysqlDatabase();
         }
         exports.REQ_DBX.listener = async (req) => {
-            if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter)
-                return DBService.allInstances[0].adapter.bulk(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;
+            }
             for (let i of DBService.allInstances) {
-                if (i.options.id === req.dbid && i.adapter)
-                    return i.adapter.bulk(req);
+                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;
+                }
             }
             const error = {
                 code: "DB_NOT_FOUND",
@@ -47,17 +104,26 @@ class DBService extends BaseService_1.BaseService {
             };
             let result = [];
             for (let i of req.bulk) {
-                result.push({ error: error });
+                result.push({
+                    error: error, execution: {
+                        started_at: executionStartTime,
+                        finished_at: Date.now()
+                    }
+                });
                 if (i.throwable)
                     throw error;
             }
             return result;
         };
         exports.REQ_DB_TBEGIN.listener = async (req) => {
+            const executionStartTime = Date.now();
             const adapter = this.getAdapter(req.dbid);
             if ("errno" in adapter) {
                 return {
-                    error: adapter
+                    error: adapter, execution: {
+                        started_at: executionStartTime,
+                        finished_at: Date.now()
+                    }
                 };
             }
             if (adapter.tBegin && typeof adapter.tBegin === "function")
@@ -71,14 +137,21 @@ class DBService extends BaseService_1.BaseService {
                     name: "TRX_NOT_SUPPORTED",
                     message: "Transactions not supported on selected adapter",
                     isDuplicateError: false
+                }, execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
                 }
             };
         };
         exports.REQ_DB_TCOMMIT.listener = async (req) => {
+            const executionStartTime = Date.now();
             const adapter = this.getAdapter(req.dbid);
             if ("errno" in adapter) {
                 return {
-                    error: adapter
+                    error: adapter, execution: {
+                        started_at: executionStartTime,
+                        finished_at: Date.now()
+                    }
                 };
             }
             if (adapter.tCommit && typeof adapter.tCommit === "function")
@@ -92,14 +165,21 @@ class DBService extends BaseService_1.BaseService {
                     name: "TRX_NOT_SUPPORTED",
                     message: "Transactions not supported on selected adapter",
                     isDuplicateError: false
+                }, execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
                 }
             };
         };
         exports.REQ_DB_TROLLBACK.listener = async (req) => {
+            const executionStartTime = Date.now();
             const adapter = this.getAdapter(req.dbid);
             if ("errno" in adapter) {
                 return {
-                    error: adapter
+                    error: adapter, execution: {
+                        started_at: executionStartTime,
+                        finished_at: Date.now()
+                    }
                 };
             }
             if (adapter.tRollback && typeof adapter.tRollback === "function")
@@ -113,15 +193,25 @@ class DBService extends BaseService_1.BaseService {
                     name: "TRX_NOT_SUPPORTED",
                     message: "Transactions not supported on selected adapter",
                     isDuplicateError: false
+                }, execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
                 }
             };
         };
         exports.REQ_DB.listener = async (req) => {
-            if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter)
-                return DBService.allInstances[0].adapter.query(req);
+            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;
+            }
             for (let i of DBService.allInstances) {
-                if (i.options.id === req.dbid && i.adapter)
-                    return i.adapter.query(req);
+                if (i.options.id === req.dbid && i.adapter) {
+                    const result = await i.adapter.query(req);
+                    this.reportQuery(result, req);
+                    return result;
+                }
             }
             const error = {
                 code: "DB_NOT_FOUND",
@@ -132,9 +222,16 @@ class DBService extends BaseService_1.BaseService {
                 message: "DB not found: " + req.dbid,
                 isDuplicateError: false
             };
+            const errorResult = {
+                error: error, execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
+            };
+            this.reportQuery(errorResult, req);
             if (req.throwable)
                 throw error;
-            return { error: error };
+            return errorResult;
         };
     }
     getAdapter(dbid) {
@@ -155,6 +252,33 @@ class DBService extends BaseService_1.BaseService {
         };
         return error;
     }
+    async reportQuery(result, req) {
+        const hour = (new Date().getHours() + 1).toString().padStart(2, "0");
+        if (this.queriesStat.hour !== hour) {
+            this.queriesStat.hour = hour;
+            this.queriesStat.stat = { failed: 0, success: 0 };
+        }
+        if (result.error)
+            this.queriesStat.stat.failed++;
+        else
+            this.queriesStat.stat.success++;
+        const execTime = result.execution.finished_at - result.execution.started_at;
+        if (execTime && execTime > 0) {
+            for (let i of this.longQueries) {
+                if (execTime > i.execution) {
+                    this.longQueries.push({
+                        execution: execTime,
+                        query: req.query,
+                        started_at: result.execution.started_at,
+                        finished_at: result.execution.finished_at
+                    });
+                }
+            }
+            this.longQueries.sort((a, b) => a.execution - b.execution);
+            if (this.longQueries.length > 20)
+                this.longQueries = this.longQueries.slice(-20);
+        }
+    }
     async finishService() {
         await this.adapter?.finish();
     }

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

@@ -1,4 +1,4 @@
-import { IDBBulkQuery, IDBQuery, IDBResult } from "../DBService";
+import { IDBBulkQuery, IDBQuery, IDBResult, IPoolStatus } from "../DBService";
 export interface IDBAdapter {
     init(): Promise<void>;
     finish(): Promise<void>;
@@ -8,4 +8,5 @@ export interface IDBAdapter {
     prepareQuery(request: IDBQuery): string;
     query(request: IDBQuery): Promise<IDBResult>;
     bulk(request: IDBBulkQuery): Promise<IDBResult[]>;
+    poolStatus(): IPoolStatus;
 }

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

@@ -32,6 +32,11 @@ export declare class MysqlAdapter implements IDBAdapter {
     acquiredPoolConnections: number;
     constructor(options: DBAdapterOptions);
     init(): Promise<void>;
+    poolStatus(): {
+        lastSuccessQueryTime: string;
+        poolConnections: number;
+        acquiredPoolConnections: number;
+    };
     setupTimers(): void;
     recreatePool(): Promise<boolean>;
     tBegin(): Promise<IDBResult>;
@@ -39,6 +44,7 @@ export declare class MysqlAdapter implements IDBAdapter {
     tRollback(trxid: number): Promise<IDBResult>;
     bulk(request: IDBBulkQuery): Promise<IDBResult[]>;
     getConnection(transactionId?: number): Promise<mysql.PoolConnection | IDBError>;
+    withTimeout<T>(promise: Promise<T>, ms: number, query: string): Promise<T>;
     query(request: IDBQuery, conn?: mysql.PoolConnection): Promise<IDBResult>;
     finalizeConnection(conn: mysql.PoolConnection): void;
     prepareQuery(request: IDBQuery): string;

package/dist/apiServer/db/MysqlAdapter.js

@@ -61,6 +61,13 @@ class MysqlAdapter {
         }
         this.setupTimers();
     }
+    poolStatus() {
+        return {
+            lastSuccessQueryTime: new Date(this.lastSuccessQueryTime).toISOString(),
+            poolConnections: this.poolConnections,
+            acquiredPoolConnections: this.acquiredPoolConnections
+        };
+    }
     setupTimers() {
         setInterval(() => {
             const now = Date.now();
@@ -155,9 +162,16 @@ class MysqlAdapter {
         return true;
     }
     async tBegin() {
+        const executionStartTime = Date.now();
         const conn = await this.getConnection();
         if (isError(conn))
-            return { error: conn };
+            return {
+                error: conn,
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
+            };
         for (let i of this.transactions) {
             if (i.conn === conn) {
                 (0, LogService_1.logError)("Selected connection is in transaction");
@@ -170,6 +184,10 @@ class MysqlAdapter {
                         name: "CONN_IN_TRX",
                         message: "Selected connection already in transaction",
                         isDuplicateError: false
+                    },
+                    execution: {
+                        started_at: executionStartTime,
+                        finished_at: Date.now()
                     }
                 };
             }
@@ -194,9 +212,16 @@ class MysqlAdapter {
         this.transactions.push(trxRequest);
         if (this.options.debug)
             (0, LogService_1.logDB)("Transactions pool: ", this.transactions.map(t => "id:" + t.id + ", queries: " + t.queries.length));
-        return { data: { transactionId: trxid } };
+        return {
+            data: { transactionId: trxid },
+            execution: {
+                started_at: executionStartTime,
+                finished_at: Date.now()
+            }
+        };
     }
     async tCommit(trxid) {
+        const executionStartTime = Date.now();
         const trx = this.transactions.find(i => i.id === trxid);
         if (!trx) {
             return {
@@ -208,6 +233,10 @@ class MysqlAdapter {
                     name: "NO_TRX",
                     message: "Transaction not found",
                     isDuplicateError: false
+                },
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
                 }
             };
         }
@@ -218,13 +247,27 @@ class MysqlAdapter {
             (0, LogService_1.logDB)("Transaction pool:", this.transactions);
         const err = await this.commit(trx);
         if (err)
-            return { error: err };
-        return { data: true };
+            return {
+                error: err,
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
+            };
+        return {
+            data: true,
+            execution: {
+                started_at: executionStartTime,
+                finished_at: Date.now()
+            }
+        };
     }
     async tRollback(trxid) {
+        const executionStartTime = Date.now();
         const trx = this.transactions.find(i => i.id === trxid);
         if (!trx) {
-            return { error: {
+            return {
+                error: {
                     code: "NO_TRX",
                     errno: 100004,
                     fatal: true,
@@ -232,12 +275,24 @@ class MysqlAdapter {
                     name: "NO_TRX",
                     message: "Transaction not found",
                     isDuplicateError: false
-                } };
+                },
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
+            };
         }
         await this.rollbackTransaction(trx);
-        return { data: true };
+        return {
+            data: true,
+            execution: {
+                started_at: executionStartTime,
+                finished_at: Date.now()
+            }
+        };
     }
     async bulk(request) {
+        const executionStartTime = Date.now();
         const results = [];
         let queries = [];
         let conn = null;
@@ -245,7 +300,13 @@ class MysqlAdapter {
             conn = await this.getConnection();
             if (isError(conn)) {
                 for (let i of request.bulk)
-                    results.push({ data: null, error: conn });
+                    results.push({
+                        data: null, error: conn,
+                        execution: {
+                            started_at: executionStartTime,
+                            finished_at: Date.now()
+                        }
+                    });
                 return results;
             }
         }
@@ -265,15 +326,15 @@ class MysqlAdapter {
                 throwable: i.throwable,
             }));
         }
-        if (conn) {
-            this.finalizeConnection(conn);
-            conn = null;
-        }
         if (queries && queries.length > 0) {
             const responses = await Promise.all(queries);
             for (let i of responses)
                 results.push(i);
         }
+        if (conn) {
+            this.finalizeConnection(conn);
+            conn = null;
+        }
         return results;
     }
     async getConnection(transactionId) {
@@ -307,8 +368,10 @@ class MysqlAdapter {
                 return conn;
         }
         catch (e) {
-            if (`${e}`.indexOf('ECONNREFUSED') !== -1)
+            if (`${e}`.indexOf('ECONNREFUSED') !== -1 || `${e}`.indexOf("PROTOCOL_") !== -1 || `${e}`.includes("closed state")) {
+                (0, LogService_1.logError)("Connection looks dead, recreating pool 2");
                 this.recreatePool();
+            }
         }
         (0, LogService_1.logCrit)("${MysqlAdapter.js}", `No connection created!`);
         return {
@@ -321,14 +384,44 @@ class MysqlAdapter {
             isDuplicateError: false
         };
     }
+    withTimeout(promise, ms, query) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject({
+                    code: "TIME_OUT",
+                    errno: 100013,
+                    sql: query,
+                    name: "TIME_OUT",
+                    fatal: true,
+                    message: "Query timeout reached " + ms
+                });
+            }, ms);
+            promise.then((res) => {
+                clearTimeout(timeout);
+                resolve(res);
+            }).catch((err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
     async query(request, conn) {
+        let executionStartTime = Date.now();
         const query = this.prepareQuery(request);
-        if (this.options.debug || request.debug)
-            (0, LogService_1.logDB)(query);
+        if (this.options.debug || request.debug) {
+            if (query.toLowerCase().trim().indexOf("select 1") === -1)
+                (0, LogService_1.logDB)(query);
+        }
         if (request.parseQueryOnly) {
+            if (conn && !request.transactionID)
+                this.finalizeConnection(conn);
             return {
                 data: [{ query }],
                 error: null,
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
             };
         }
         let doCloseConnection = false;
@@ -339,17 +432,29 @@ class MysqlAdapter {
                 return {
                     data: null,
                     error: conn,
+                    execution: {
+                        started_at: executionStartTime,
+                        finished_at: Date.now()
+                    }
                 };
             }
         }
         try {
-            const result = await conn.query(query);
+            let result = null;
+            if (this.options.maxQueryTimeout && this.options.maxQueryTimeout > 0)
+                result = await this.withTimeout(conn.query(query), this.options.maxQueryTimeout ?? 1000 * 25, query);
+            else
+                result = await conn.query(query);
             this.lastSuccessQueryTime = +new Date();
             if (!request.transactionID && doCloseConnection)
                 this.finalizeConnection(conn);
             return {
                 data: result[0],
-                error: null
+                error: null,
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
             };
         }
         catch (e) {
@@ -364,20 +469,26 @@ class MysqlAdapter {
                 this.finalizeConnection(conn);
             }
             const error = this.createMysqlQueryError(e);
-            if (`${e}`.indexOf('ECONNREFUSED') !== -1)
+            if (`${e}`.indexOf('ECONNREFUSED') !== -1 || `${e}`.indexOf("PROTOCOL_") !== -1 || error.message.includes("closed state")) {
+                (0, LogService_1.logError)("Connection looks dead, recreating pool 1");
                 this.recreatePool();
+            }
             if (request.throwable)
                 throw { ...DefaultErrors_1.default.DB_ERROR, details: error.message, stack: error };
             return {
                 data: null,
                 error: error,
+                execution: {
+                    started_at: executionStartTime,
+                    finished_at: Date.now()
+                }
             };
         }
     }
     finalizeConnection(conn) {
         try {
-            conn.release();
             conn.removeAllListeners();
+            conn.release();
             if (this.options.debug)
                 (0, LogService_1.logDB)("Release connection: ", conn.threadId);
         }
@@ -556,7 +667,7 @@ class MysqlAdapter {
                 sql: err.sql,
                 name: err.name,
                 message: err.message,
-                fatal: false,
+                fatal: err.fatal && typeof err.fatal === "boolean" ? err.fatal : false,
                 isDuplicateError: err.code.toLowerCase().indexOf("dup_entry") !== -1
             };
         }

package/package.json

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