multi-db-orm 3.1.0 → 3.1.2

package/engines/bigquerydb.js

@@ -1,6 +1,6 @@
-const { MultiDbORM } = require("multi-db-orm");
-const { Metrics } = require("multi-db-orm/engines/metrics");
-const { Sync } = require("multi-db-orm/sync");
+const { MultiDbORM } = require("./multidb");
+const { Metrics } = require("./metrics");
+const { Sync } = require("../sync");
 // const { MultiDbORM } = require('./multidb');
 
 class BigQueryDB {

package/engines/firestoredb.js

@@ -101,13 +101,18 @@ class FireStoreDB extends MultiDbORM {
 
   async get(modelname, filter, options) {
     var result = [];
+    const span = this.metrics.getSpan();
     var snapshot = await this._get(modelname, filter, options);
-    if (snapshot == undefined) return [];
-    this.metrics.get(modelname, filter, options);
+    if (snapshot == undefined) {
+      this.metrics.get(modelname, filter, options, span);
+      return [];
+    }
+    this.metrics.get(modelname, filter, options, span);
     let that = this;
     snapshot.forEach((doc) => {
-      that.metrics.getOne(modelname, filter, options);
+      const docSpan = this.metrics.getOneSpan();
       result.push(doc.data());
+      that.metrics.getOne(modelname, filter, options, docSpan);
     });
     if (this.loglevel > 2) console.log("Retrieved ", result);
 
@@ -117,9 +122,10 @@ class FireStoreDB extends MultiDbORM {
   async getOne(modelname, filter, id, options) {
     var idx = id || filter.id;
     if (idx) {
-      this.metrics.getOne(modelname, filter, options);
+      const span = this.metrics.getOneSpan();
       const modelref = this.getdb().collection(modelname).doc(idx);
       const doc = await modelref.get();
+      this.metrics.getOne(modelname, filter, options, span);
       if (this.loglevel > 2) console.log("Retrieved ", doc.data());
       return doc.data();
     } else {
@@ -135,7 +141,8 @@ class FireStoreDB extends MultiDbORM {
 
   async create(modelname, sampleObject) {
     this.sync.create(modelname, sampleObject);
-    this.metrics.create(modelname, sampleObject);
+    const span = this.metrics.createSpan();
+    this.metrics.create(modelname, sampleObject, span);
 
     if (this.loglevel > 3)
       console.log("CREATE : Not required in DB Type", this.dbType);
@@ -144,21 +151,25 @@ class FireStoreDB extends MultiDbORM {
   async insert(modelname, object, id) {
     replaceUndefinedWithNull(object);
     this.sync.insert(modelname, object, id);
-    this.metrics.insert(modelname, object, id);
+    const span = this.metrics.insertSpan();
 
     var db = this.getdb();
     var idx = id || object.id || Date.now();
     const docref = db.collection(modelname).doc("" + idx);
     try {
       replaceUndefinedWithNull(object);
-      return await docref.set(object);
+      const res = await docref.set(object);
+      this.metrics.insert(modelname, object, id, span);
+      return res;
     } catch (e) {
       if (
         e.message.indexOf(
           "Firestore doesn't support JavaScript objects with custom prototypes"
         ) > -1
       ) {
-        return await docref.set(JSON.parse(JSON.stringify(object)));
+        const res = await docref.set(JSON.parse(JSON.stringify(object)));
+        this.metrics.insert(modelname, object, id, span);
+        return res;
       } else {
         throw e;
       }
@@ -173,16 +184,18 @@ class FireStoreDB extends MultiDbORM {
     try {
       replaceUndefinedWithNull(object);
       if (idx) {
-        this.metrics.update(modelname, filter, object, id);
+        const span = this.metrics.updateSpan();
         await this.getdb().collection(modelname).doc(idx).update(object);
+        this.metrics.update(modelname, filter, object, id, span);
       } else {
         var snaps = (await this._get(modelname, filter)) || [];
-        let that = this;
-        snaps.forEach(async function (element) {
-          that.metrics.getOne(modelname, filter, id);
-          that.metrics.update(modelname, filter, object, id);
+        const list = snaps.docs || snaps;
+        for (const element of list) {
+          const span = this.metrics.updateSpan();
           await element.ref.update(object);
-        });
+          this.metrics.getOne(modelname, filter, id, span);
+          this.metrics.update(modelname, filter, object, id, span);
+        }
       }
     } catch (e) {
       if (
@@ -208,16 +221,18 @@ class FireStoreDB extends MultiDbORM {
     var idx = id || filter.id;
 
     if (idx) {
-      this.metrics.delete(modelname, filter, id);
+      const span = this.metrics.deleteSpan();
       await this.getdb().collection(modelname).doc(idx).delete();
+      this.metrics.delete(modelname, filter, id, span);
     } else {
       var snaps = (await this._get(modelname, filter)) || [];
-      let that = this;
-      snaps.forEach(async function (element) {
-        that.metrics.getOne(modelname, filter, id);
-        that.metrics.delete(modelname, filter, id);
+      const list = snaps.docs || snaps;
+      for (const element of list) {
+        const span = this.metrics.deleteSpan();
         await element.ref.delete();
-      });
+        this.metrics.getOne(modelname, filter, id, span);
+        this.metrics.delete(modelname, filter, id, span);
+      }
     }
   }
 }

package/engines/hanadb.js

@@ -61,7 +61,7 @@ class HanaDB extends MultiDbORM {
   }
 
   async get(modelname, filter, options) {
-    this.metrics.get(modelname, filter, options);
+    const span = this.metrics.getSpan();
     let where = "";
     for (const key in filter) {
       where += `"${key}" = '${filter[key]}' AND `;
@@ -89,7 +89,9 @@ class HanaDB extends MultiDbORM {
     const limit = options?.limit ? `LIMIT ${options.limit}` : "";
     const offset = options?.offset ? `OFFSET ${options.offset}` : "";
     const query = `SELECT * FROM ${modelname} WHERE ${where} ${sort} ${limit} ${offset};`;
-    return (await this.run(query)) || [];
+    const res = (await this.run(query)) || [];
+    this.metrics.get(modelname, filter, options, span);
+    return res;
   }
   escapeSQLValue(value) {
     if (typeof value === "string") {
@@ -100,7 +102,7 @@ class HanaDB extends MultiDbORM {
     return value;
   }
   async getOne(modelname, filter) {
-    this.metrics.getOne(modelname, filter);
+    const span = this.metrics.getOneSpan();
     let where = "";
     for (const key in filter) {
       where += `"${key}" = '${filter[key]}' AND `;
@@ -108,12 +110,13 @@ class HanaDB extends MultiDbORM {
     where += "1 = 1";
     const query = `SELECT * FROM ${modelname} WHERE ${where} LIMIT 1;`;
     const row = await this.run(query);
+    this.metrics.getOne(modelname, filter, span);
     return row[0];
   }
 
   async create(modelname, sampleObject) {
     this.sync.create(modelname, sampleObject);
-    this.metrics.create(modelname, sampleObject);
+    const span = this.metrics.createSpan();
 
     let cols = "";
     for (const key in sampleObject) {
@@ -141,7 +144,9 @@ class HanaDB extends MultiDbORM {
     cols = cols.substring(0, cols.length - 1);
     const query = `CREATE COLUMN TABLE ${modelname} (${cols});`;
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.create(modelname, sampleObject, span);
+      return res;
     } catch (err) {
       if (this.loglevel > 0) console.log(err);
       throw err;
@@ -150,7 +155,7 @@ class HanaDB extends MultiDbORM {
 
   async insert(modelname, object) {
     this.sync.insert(modelname, object);
-    this.metrics.insert(modelname, object);
+    const span = this.metrics.insertSpan();
     let cols = "";
     let vals = "";
     for (const key in object) {
@@ -169,12 +174,16 @@ class HanaDB extends MultiDbORM {
     const query = `INSERT INTO ${modelname} (${cols}) VALUES (${vals});`;
 
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.insert(modelname, object, span);
+      return res;
     } catch (err) {
       if (err.code && err.code === "259") {
         // Table does not exist
         await this.create(modelname, object);
-        return await this.run(query);
+        const res = await this.run(query);
+        this.metrics.insert(modelname, object, span);
+        return res;
       } else {
         throw err;
       }
@@ -183,7 +192,7 @@ class HanaDB extends MultiDbORM {
 
   async update(modelname, filter, object) {
     this.sync.update(modelname, filter, object);
-    this.metrics.update(modelname, filter, object);
+    const span = this.metrics.updateSpan();
 
     let where = "";
     let vals = "";
@@ -203,7 +212,9 @@ class HanaDB extends MultiDbORM {
 
     const query = `UPDATE ${modelname} SET ${vals} WHERE ${where};`;
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.update(modelname, filter, object, span);
+      return res;
     } catch (e) {
       if (this.loglevel > 4) console.log("Error in update", e);
       throw e;
@@ -212,6 +223,8 @@ class HanaDB extends MultiDbORM {
 
   async delete(modelname, filter) {
     this.sync.delete(modelname, filter);
+    const span = this.metrics.deleteSpan();
+
     this.metrics.delete(modelname, filter);
 
     let where = "";
@@ -220,7 +233,9 @@ class HanaDB extends MultiDbORM {
     }
     where += "1 = 1";
     const query = `DELETE FROM ${modelname} WHERE ${where};`;
-    return await this.run(query);
+    const res = await this.run(query);
+    this.metrics.delete(modelname, filter, span);
+    return res;
   }
 
   closePool() {

package/engines/metrics.d.ts

@@ -1,5 +1,6 @@
 export class Metrics {
     constructor(loglevel: number);
+    setLogLevel(level: number): void;
     get(modelname: string, filter: any, options: any): void;
     getOne(modelname: string, filter: any): void;
     create(modelname: string, sampleObject: any): void;

package/engines/metrics.js

@@ -13,9 +13,12 @@ class Metrics {
             deletes: 0
         }
     }
+    setLogLevel(level) {
+        this.loglevel = level;
+    }
 
     printStatus() {
-        console.log(dbstats)
+        console.log(this.dbstats)
     }
 
     reset() {
@@ -34,39 +37,116 @@ class Metrics {
     }
 
     async get(modelname, filter) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
         this.dbstats.batchReads++;
         if (this.loglevel > 4)
             this.printStatus()
+        this._logOperation(modelname, 'get', start, { filter })
     }
 
     async getOne(modelname, filter) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
         this.dbstats.reads++;
         if (this.loglevel > 4)
             this.printStatus()
+        this._logOperation(modelname, 'getOne', start, { filter })
     }
 
     async create(modelname, object) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
         this.dbstats.inserts++;
         if (this.loglevel > 4)
             this.printStatus()
+        this._logOperation(modelname, 'create', start, { object })
     }
 
     async insert(modelname, object) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
         this.dbstats.inserts++;
         if (this.loglevel > 4)
-            printStatus()
+            this.printStatus()
+        this._logOperation(modelname, 'insert', start, { object })
     }
 
     async update(modelname, filter, object) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
         this.dbstats.updates++;
         if (this.loglevel > 4)
             this.printStatus()
+        this._logOperation(modelname, 'update', start, { filter, object })
     }
 
     async delete(modelname, filter) {
+        const args = Array.from(arguments)
+        const last = args[args.length - 1]
+        const start = last && typeof last === 'object' && last.startTime ? last.startTime : process.hrtime.bigint()
         this.dbstats.deletes++;
         if (this.loglevel > 4)
             this.printStatus()
+        this._logOperation(modelname, 'delete', start, { filter })
+    }
+
+    _safeStringify(v) {
+        try {
+            return JSON.stringify(v)
+        } catch (e) {
+            return String(v)
+        }
+    }
+
+    startSpan(operation) {
+        return { startTime: process.hrtime.bigint(), operation }
+    }
+
+    updateSpan() {
+        return this.startSpan('update')
+    }
+
+    insertSpan() {
+        return this.startSpan('insert')
+    }
+
+    getSpan() {
+        return this.startSpan('get')
+    }
+
+    getOneSpan() {
+        return this.startSpan('getOne')
+    }
+
+    createSpan() {
+        return this.startSpan('create')
+    }
+
+    deleteSpan() {
+        return this.startSpan('delete')
+    }
+
+    _logOperation(modelname, operation, startTime, details) {
+        if (!(this.loglevel > 3)) return
+        const elapsedMs = Number(process.hrtime.bigint() - startTime) / 1e6
+        if (this.loglevel > 4) {
+            const parts = []
+            if (details) {
+                if (details.filter !== undefined) parts.push(`filter=${this._safeStringify(details.filter)}`)
+                if (details.object !== undefined) parts.push(`object=${this._safeStringify(details.object)}`)
+                if (details.sort !== undefined) parts.push(`sort=${this._safeStringify(details.sort)}`)
+            }
+            const detailStr = parts.length ? parts.join(' ') : ''
+            console.log(`${operation} ${modelname} in ${elapsedMs.toFixed(3)}ms`, detailStr)
+        } else {
+            console.log(`${operation} ${modelname} in ${elapsedMs.toFixed(3)}ms`)
+        }
     }
 
 }

package/engines/mongodb.js

@@ -53,7 +53,7 @@ class MongoDB extends MultiDbORM {
         }
     }
     async get(modelname, filter, options) {
-        this.metrics.get(modelname, filter, options);
+        const span = this.metrics.getSpan();
         if (options && options.apply && options.apply.ineq) {
             filter[`${options.apply.field}`] = {};
             filter[`${options.apply.field}`][`${this._inq2mongop(options.apply.ineq.op)}`] = options.apply.ineq.value
@@ -94,19 +94,22 @@ class MongoDB extends MultiDbORM {
         }
 
         var snapshot = await crs.toArray()
+        this.metrics.get(modelname, filter, options, span);
         return snapshot;
 
     }
 
     async getOne(modelname, filter, options) {
-        this.metrics.getOne(modelname, filter, options);
+        const span = this.metrics.getOneSpan();
         var snapshot = await this.getdb().collection(modelname).findOne(filter)
+        this.metrics.getOne(modelname, filter, options, span);
         return snapshot;
     }
 
     async create(modelname, sampleObject) {
         this.sync.create(modelname, sampleObject)
-        this.metrics.create(modelname, sampleObject);
+        const span = this.metrics.createSpan();
+        this.metrics.create(modelname, sampleObject, span);
 
         if (this.loglevel > 3)
             console.log('CREATE : Not required in DB Type', this.dbType)
@@ -114,11 +117,13 @@ class MongoDB extends MultiDbORM {
 
     async insert(modelname, object) {
         this.sync.insert(modelname, object)
-        this.metrics.insert(modelname, object)
+        const span = this.metrics.insertSpan();
 
         const collref = this.getdb().collection(modelname)
         try {
-            return await collref.insertOne(object);
+            const res = await collref.insertOne(object);
+            this.metrics.insert(modelname, object, span);
+            return res;
         } catch (e) {
 
             throw e;
@@ -129,15 +134,17 @@ class MongoDB extends MultiDbORM {
 
     async update(modelname, filter, object) {
         this.sync.update(modelname, filter, object)
-        this.metrics.update(modelname, filter, object)
+        const span = this.metrics.updateSpan();
         var resp = await this.getdb().collection(modelname).updateMany(filter, { $set: object })
+        this.metrics.update(modelname, filter, object, span)
         return resp;
     }
 
     async delete(modelname, filter) {
         this.sync.delete(modelname, filter)
-        this.metrics.delete(modelname, filter)
+        const span = this.metrics.deleteSpan();
         var resp = await this.getdb().collection(modelname).deleteMany(filter)
+        this.metrics.delete(modelname, filter, span)
         return resp;
     }
 }

package/engines/multidb.d.ts

@@ -9,6 +9,8 @@ export class MultiDbORM {
 
     constructor(db: any);
 
+    setLogLevel(level: number): void;
+
     connect(): Promise<void>;
 
     setdb(db: any): void;

package/engines/multidb.js

@@ -16,6 +16,11 @@ class MultiDbORM {
         this.metrics = new Metrics(this.loglevel)
     }
 
+    setLogLevel(level) {
+        this.loglevel = level;
+        this.metrics.setLogLevel(level);
+    }
+
     async connect() {
 
     }

package/engines/mysqldb.js

@@ -64,7 +64,7 @@ class MySQLDB extends MultiDbORM {
   }
 
   async get(modelname, filter, options) {
-    this.metrics.get(modelname, filter, options);
+    const span = this.metrics.getSpan();
     var where = "";
     for (var key in filter) {
       where = where + `${key} = '${filter[key]}' AND `;
@@ -100,11 +100,13 @@ class MySQLDB extends MultiDbORM {
       offset = `OFFSET ${options.offset}`;
     }
     var query = `SELECT * FROM ${modelname} WHERE ${where} ${sort} ${limit} ${offset};`;
-    return (await this.run(query)) || [];
+    const res = (await this.run(query)) || [];
+    this.metrics.get(modelname, filter, options, span);
+    return res;
   }
 
   async getOne(modelname, filter) {
-    this.metrics.getOne(modelname, filter);
+    const span = this.metrics.getOneSpan();
     var where = "";
     for (var key in filter) {
       where = where + `${key} = '${filter[key]}' AND `;
@@ -112,11 +114,12 @@ class MySQLDB extends MultiDbORM {
     where = where + " 1 ";
     var query = `SELECT * FROM ${modelname} WHERE ${where} LIMIT 1;`;
     var row = await this.run(query);
+    this.metrics.getOne(modelname, filter, span);
     return row[0];
   }
   async create(modelname, sampleObject) {
     this.sync.create(modelname, sampleObject);
-    this.metrics.create(modelname, sampleObject);
+    const span = this.metrics.createSpan();
 
     var cols = "";
     for (var key in sampleObject) {
@@ -144,7 +147,9 @@ class MySQLDB extends MultiDbORM {
     cols = cols.substring(0, cols.length - 1);
     var query = `CREATE TABLE IF NOT EXISTS ${modelname} (${cols});`;
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.create(modelname, sampleObject, span);
+      return res;
     } catch (err) {
       if (this.loglevel > 0) console.log(err);
       throw err;
@@ -153,7 +158,7 @@ class MySQLDB extends MultiDbORM {
 
   async insert(modelname, object) {
     this.sync.insert(modelname, object);
-    this.metrics.insert(modelname, object);
+    const span = this.metrics.insertSpan();
     var cols = "";
     var vals = "";
     for (var key in object) {
@@ -171,11 +176,15 @@ class MySQLDB extends MultiDbORM {
     var query = `INSERT INTO ${modelname} (${cols}) VALUES(${vals});`;
 
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.insert(modelname, object, span);
+      return res;
     } catch (err) {
       if (err.code && err.code === "ER_NO_SUCH_TABLE") {
         await this.create(modelname, object);
-        return await this.run(query);
+        const res = await this.run(query);
+        this.metrics.insert(modelname, object, span);
+        return res;
       } else {
         throw err;
       }
@@ -184,7 +193,7 @@ class MySQLDB extends MultiDbORM {
 
   async update(modelname, filter, object) {
     this.sync.update(modelname, filter, object);
-    this.metrics.update(modelname, filter, object);
+    const span = this.metrics.updateSpan();
 
     var where = "";
     var vals = "";
@@ -212,7 +221,9 @@ class MySQLDB extends MultiDbORM {
 
     var query = `UPDATE ${modelname} SET ${vals} WHERE ${where};`;
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.update(modelname, filter, object, span);
+      return res;
     } catch (e) {
       if (this.loglevel > 4) console.log("Error in update", e);
       throw e;
@@ -221,7 +232,7 @@ class MySQLDB extends MultiDbORM {
 
   async delete(modelname, filter) {
     this.sync.delete(modelname, filter);
-    this.metrics.delete(modelname, filter);
+    const span = this.metrics.deleteSpan();
 
     var where = "";
     for (var key in filter) {
@@ -229,7 +240,9 @@ class MySQLDB extends MultiDbORM {
     }
     where = where + " 1 ";
     var query = `DELETE FROM ${modelname} WHERE ${where};`;
-    return await this.run(query);
+    const res = await this.run(query);
+    this.metrics.delete(modelname, filter, span);
+    return res;
   }
 
   closePool() {

package/engines/oracledb.js

@@ -110,7 +110,7 @@ class OracleDB extends MultiDbORM {
     }
 
     async get(modelname, filter, options) {
-        this.metrics.get(modelname, filter, options)
+        const span = this.metrics.getSpan()
         var where = ''
         for (var key in filter) {
             where = where + `"${key}" = '${filter[key]}' AND `
@@ -139,12 +139,13 @@ class OracleDB extends MultiDbORM {
         }
         var query = `SELECT * FROM ${modelname} WHERE ${where} ${sort} `
         var row = await this.run(query)
+        this.metrics.get(modelname, filter, options, span)
 
         return row.rows
     }
 
     async getOne(modelname, filter) {
-        this.metrics.getOne(modelname, filter)
+        const span = this.metrics.getOneSpan()
         var where = ''
         for (var key in filter) {
             where = where + `"${key}" = '${filter[key]}' AND `
@@ -152,12 +153,13 @@ class OracleDB extends MultiDbORM {
         where = where + " 1 = 1 ";
         var query = `SELECT * FROM ${modelname} WHERE ${where} AND rownum < 2`
         var row = await this.run(query)
+        this.metrics.getOne(modelname, filter, span)
         return row.rows[0];
     }
 
     async create(modelname, sampleObject) {
         this.sync.create(modelname, sampleObject)
-        this.metrics.create(modelname, sampleObject)
+        const span = this.metrics.createSpan()
 
         var cols = ''
         for (var key in sampleObject) {
@@ -173,7 +175,9 @@ class OracleDB extends MultiDbORM {
         cols = cols.substring(0, cols.length - 2)
         var query = `CREATE TABLE ${modelname} (${cols})`
         try {
-            return await this.run(query)
+            const res = await this.run(query)
+            this.metrics.create(modelname, sampleObject, span)
+            return res
         } catch (err) {
             if (!err.message.indexOf("name is already used")) {
                 console.log(err)
@@ -184,7 +188,7 @@ class OracleDB extends MultiDbORM {
 
     async insert(modelname, object) {
         this.sync.insert(modelname, object)
-        this.metrics.insert(modelname, object)
+        const span = this.metrics.insertSpan()
         var cols = ''
         var vals = ''
         for (var key in object) {
@@ -200,11 +204,15 @@ class OracleDB extends MultiDbORM {
         var query = `INSERT INTO ${modelname} (${cols}) VALUES(${vals})`
 
         try {
-            return await this.run(query)
+            const res = await this.run(query)
+            this.metrics.insert(modelname, object, span)
+            return res
         } catch (err) {
             if (err.message && err.message.indexOf('SQLITE_ERROR: no such table: ') > -1) {
                 await this.create(modelname, object);
-                return await this.run(query)
+                const res = await this.run(query)
+                this.metrics.insert(modelname, object, span)
+                return res
             }
             else
                 throw err;
@@ -213,6 +221,8 @@ class OracleDB extends MultiDbORM {
 
     async update(modelname, filter, object) {
         this.sync.update(modelname, filter, object)
+        const span = this.metrics.updateSpan()
+
         this.metrics.update(modelname, filter, object)
 
         var where = ''
@@ -227,11 +237,15 @@ class OracleDB extends MultiDbORM {
         vals = vals.substring(0, vals.length - 1)
 
         var query = `UPDATE ${modelname} SET ${vals} WHERE ${where}`
-        return await this.run(query)
+        const res = await this.run(query)
+        this.metrics.update(modelname, filter, object, span)
+        return res
     }
 
     async delete(modelname, filter) {
         this.sync.delete(modelname, filter)
+        const span = this.metrics.deleteSpan()
+
         this.metrics.delete(modelname, filter)
 
         var where = ''
@@ -240,7 +254,9 @@ class OracleDB extends MultiDbORM {
         }
         where = where + " 1 = 1";
         var query = `DELETE FROM ${modelname} WHERE ${where}`
-        return await this.run(query)
+        const res = await this.run(query)
+        this.metrics.delete(modelname, filter, span)
+        return res
     }
 }
 

package/engines/sqlitedb.js

@@ -39,7 +39,7 @@ class SQLiteDB extends MultiDbORM {
   }
 
   async get(modelname, filter, options) {
-    this.metrics.get(modelname, filter, options);
+    const span = this.metrics.getSpan();
     var where = "";
     for (var key in filter) {
       where = where + `${key} = '${filter[key]}' AND `;
@@ -67,11 +67,13 @@ class SQLiteDB extends MultiDbORM {
       }
     }
     var query = `SELECT * FROM ${modelname} WHERE ${where} ${sort} ;`;
-    return (await this.run(query)) || [];
+    const res = (await this.run(query)) || [];
+    this.metrics.get(modelname, filter, options, span);
+    return res;
   }
 
   async getOne(modelname, filter) {
-    this.metrics.getOne(modelname, filter);
+    const span = this.metrics.getOneSpan();
     var where = "";
     for (var key in filter) {
       where = where + `${key} = '${filter[key]}' AND `;
@@ -79,12 +81,13 @@ class SQLiteDB extends MultiDbORM {
     where = where + " 1 ";
     var query = `SELECT * FROM ${modelname} WHERE ${where} LIMIT 1;`;
     var row = await this.run(query);
+    this.metrics.getOne(modelname, filter, span);
     return row[0];
   }
 
   async create(modelname, sampleObject) {
     this.sync.create(modelname, sampleObject);
-    this.metrics.create(modelname, sampleObject);
+    const span = this.metrics.createSpan();
 
     var cols = "";
     for (var key in sampleObject) {
@@ -94,7 +97,9 @@ class SQLiteDB extends MultiDbORM {
     cols = cols.substring(0, cols.length - 1);
     var query = `CREATE TABLE IF NOT EXISTS ${modelname} (${cols});`;
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.create(modelname, sampleObject, span);
+      return res;
     } catch (err) {
       console.log(err);
       return undefined;
@@ -103,7 +108,7 @@ class SQLiteDB extends MultiDbORM {
 
   async insert(modelname, object) {
     this.sync.insert(modelname, object);
-    this.metrics.insert(modelname, object);
+    const span = this.metrics.insertSpan();
     var cols = "";
     var vals = "";
     for (var key in object) {
@@ -116,21 +121,25 @@ class SQLiteDB extends MultiDbORM {
     var query = `INSERT INTO ${modelname} (${cols}) VALUES(${vals});`;
 
     try {
-      return await this.run(query);
+      const res = await this.run(query);
+      this.metrics.insert(modelname, object, span);
+      return res;
     } catch (err) {
       if (
         err.message &&
         err.message.indexOf("SQLITE_ERROR: no such table: ") > -1
       ) {
         await this.create(modelname, object);
-        return await this.run(query);
+        const res = await this.run(query);
+        this.metrics.insert(modelname, object, span);
+        return res;
       } else throw err;
     }
   }
 
   async update(modelname, filter, object) {
     this.sync.update(modelname, filter, object);
-    this.metrics.update(modelname, filter, object);
+    const span = this.metrics.updateSpan();
 
     var where = "";
     var vals = "";
@@ -144,12 +153,14 @@ class SQLiteDB extends MultiDbORM {
     vals = vals.substring(0, vals.length - 1);
 
     var query = `UPDATE ${modelname} SET ${vals} WHERE ${where};`;
-    return await this.run(query);
+    const res = await this.run(query);
+    this.metrics.update(modelname, filter, object, span);
+    return res;
   }
 
   async delete(modelname, filter) {
     this.sync.delete(modelname, filter);
-    this.metrics.delete(modelname, filter);
+    const span = this.metrics.deleteSpan();
 
     var where = "";
     for (var key in filter) {
@@ -157,7 +168,9 @@ class SQLiteDB extends MultiDbORM {
     }
     where = where + " 1 ";
     var query = `DELETE FROM ${modelname} WHERE ${where};`;
-    return await this.run(query);
+    const res = await this.run(query);
+    this.metrics.delete(modelname, filter, span);
+    return res;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multi-db-orm",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "CRUD , Backup , Restore and Migration library for multiple databases",
   "main": "index.js",
   "dependencies": {
@@ -16,7 +16,7 @@
     "sqlite3": "^5.0.0"
   },
   "scripts": {
-    "release": "git add -A && git commit -m Update-Files & npm version patch && git add -A && git commit -m Update-Version & npm publish && git push",
+    "release": "git add -A && git commit -m Update-Files & npm version patch && git add -A && git commit -m Update-Version & npm login && npm publish && git push",
     "postinstall": "node postinstall.js",
     "test": "node test/test.js"
   },
@@ -47,4 +47,4 @@
     "url": "https://github.com/shiveshnavin/multi-db-orm/issues"
   },
   "homepage": "https://github.com/shiveshnavin/multi-db-orm#readme"
-}
+}

package/test/test.js

@@ -20,6 +20,7 @@ function checkTestsCompleted() {
 
 async function testSqlite() {
   var sqlitedb = new SQLiteDB();
+  sqlitedb.setLogLevel(10);
   console.log(sqlitedb.metrics.getStatus());
   var gm = new Game("IndVSPak", Date.now(), "Dhoni", 67.33, "paid");
   sqlitedb.loglevel = 1;
@@ -426,9 +427,5 @@ async function test(db) {
   checkTestsCompleted();
 }
 
-// testSqlite();
-// testFireStore();
-// testMongo();
-// testOracleDb()
-// testMysqlDb();
-testHanaDb();
+// run only sqlite tests for validation
+testSqlite();