add: use denque as Deque backend to implement a rate limiter for reloadDb

Author: Odaimoko

package-lock.json

@@ -35,6 +35,7 @@
     },
     "dependencies": {
         "chai": "^4.3.10",
+        "denque": "^2.1.0",
         "html-react-parser": "^4.2.7",
         "react-dom": "^18.2.0"
     },

package.json

@@ -26,7 +26,8 @@ import {OdaProjectTree} from "./OdaProjectTree";
 import {assertDatabase} from "../test_runtime";
 import {ModuleId_Unclassified, OdaPmModule} from "./OdaPmModule";
 import OdaPmToolPlugin from "../main";
-import {TimeChecker} from "../utils/TimeChecker";
+
+import {RateLimiter} from "../utils/RateLimiter";
 
 const dv = getAPI(); // We can use dv just like the examples in the docs
 
@@ -234,11 +235,7 @@ export class OdaPmDb implements I_EvtListener {
     private plugin: OdaPmToolPlugin;
 // region rate limit
     // refresh db at least once 3 seconds
-    timer: TimeChecker = new TimeChecker(3000);
-    // if the db is queuedReload to reload during the rate limitation. 
-    // True only when reloadDb is requested but rate is still limited.
-    queuedReload = false;
-    timerId: NodeJS.Timeout;
+    rateLimiter: RateLimiter = new RateLimiter(3, 1 / 3, 3)
 
 // endregion
 
@@ -254,16 +251,11 @@ export class OdaPmDb implements I_EvtListener {
         this.emitter.on(DataviewMetadataChangeEvent, this.boundReloadWorkflows)
         this.emitter.on(Evt_ReqDbReload, this.boundReloadWorkflows)
 
-        this.timerId = setTimeout(() => {
-            if (this.queuedReload)
-                this.reloadDb();
-        }, 2000)
     }
 
     rmListener(): void {
         this.emitter.off(DataviewMetadataChangeEvent, this.boundReloadWorkflows)
         this.emitter.off(Evt_ReqDbReload, this.boundReloadWorkflows)
-        clearTimeout(this.timerId)
     }
 
 // region Init
@@ -272,16 +264,13 @@ export class OdaPmDb implements I_EvtListener {
             devLog("[Event] dataviewReady is false. reloadDb canceled.")
             return;
         }
-        this.queuedReload = true;
-        if (!this.timer.isOver()) {
-            devLog(`[Event] reloadDb canceled because timer is not ready: ${this.timer.elapsed()} < ${this.timer.thresMs}`);
+        if (!this.rateLimiter.addRequest("rate")) {
+
+            devLog(`[Event] reloadDb canceled because rateLimiter is not ready`);
             return;
         }
 
-//#ifdef DEVELOPMENT_BUILD
-        this.timer.reset();
         devTime("[Event] [Timed] reloadDb")
-//#endif
         // cache for faster calc
         devTime("[Event] [Timed] getAllFiles")
         const allFiles = getAllFiles();
@@ -323,10 +312,7 @@ export class OdaPmDb implements I_EvtListener {
         this.emit(Evt_DbReloaded)
         assertDatabase(this);
         devLog("Database Reloaded.")
-//#ifdef DEVELOPMENT_BUILD
         devTimeEnd("[Event] [Timed] reloadDb")
-//#endif
-        this.queuedReload = false;
     }
 
 

src/data-model/OdaPmDb.ts

@@ -379,7 +379,7 @@ export default class OdaPmToolPlugin extends Plugin {
         }));
         // @ts-ignore
         this.registerEvent(this.app.metadataCache.on(DataviewMetadataChangeEvent, (...args) => {
-            devLog(`[Event] DataviewMetadataChangeEvent: ${DataviewMetadataChangeEvent} Triggered. args:`, args)
+            // devLog(`[Event] DataviewMetadataChangeEvent: ${DataviewMetadataChangeEvent} Triggered. args:`, args)
             this.emitter.emit(DataviewMetadataChangeEvent, ...args);
         }));
         // Don't use DataviewIndexReadyEvent, because it is fired when the full index is processed.

src/main.ts

@@ -0,0 +1,100 @@
+import Denque from "denque";
+import {devLog} from "./env-util";
+
+class TimedItem<T> {
+    timestamp: number;
+    item: T;
+}
+
+
+/**
+ * Rate limiter for burst requests.
+ * We may face the problem of too many requests in a short time, in which case we can lower the allowReqRateThres.
+ * If req freq > allowReqRateThres, we do not respond it at all.
+ * Instead, when a new request comes, we update the allowReqRateThres.
+ */
+export class RateLimiter {
+    requestedQueue: Denque<TimedItem<any>>
+    respondedQueue: Denque<TimedItem<any>>
+
+    maxRate = 3; // 3 times/s
+    minRate: number = 1 / 3; //1 time/3s
+    window = 1; // in seconds
+    // if req freq is too much we do not send response. So we respond only when reqFreq <= allowReqRateThres.
+    allowReqRateThres: number
+
+    // if req freq > adjustReqRateThres, lower the allowReqRateThres
+    adjustReqRateThres = 3;
+
+    constructor(maxRate: number, minRate: number, window: number) {
+        this.maxRate = maxRate;
+        this.minRate = minRate;
+        this.allowReqRateThres = maxRate;
+        this.window = window;
+        this.requestedQueue = new Denque<TimedItem<any>>();
+        this.respondedQueue = new Denque<TimedItem<any>>();
+    }
+
+    // returns: can this request be responded?
+    public addRequest(item: any): boolean {
+        const timedItem = new TimedItem<any>();
+        timedItem.item = item;
+        timedItem.timestamp = Date.now();
+        this.requestedQueue.push(timedItem)
+        devLog(`[Rate] ReqQueue push: `, item)
+        const reqFreq = this.calcFreq(this.window, this.requestedQueue);
+        // const respFreq = this.calcFreq(this.window, this.respondedQueue);
+        const allow = reqFreq <= this.allowReqRateThres;
+        this.cleanQueue();
+        if (allow) {
+            this.respondedQueue.push(timedItem)
+        }
+        this.adjustThres(reqFreq)
+        return allow;
+    }
+
+    private cleanQueue() {
+        const now = Date.now();
+        // front is the oldest event
+        //#ifdef DEVELOPMENT_BUILD
+        const oldReqQueueSize = this.requestedQueue.length;
+        const oldRespQueueSize = this.respondedQueue.length;
+        //#endif
+        while (this.requestedQueue.peekFront() && this.requestedQueue.peekFront()!.timestamp < now - this.window * 1000) {
+            this.requestedQueue.shift();
+        }
+        while (this.respondedQueue.peekFront() && this.respondedQueue.peekFront()!.timestamp < now - this.window * 1000) {
+            this.respondedQueue.shift();
+        }
+        //#ifdef DEVELOPMENT_BUILD
+        console.log(`[Rate] reqQueue: ${this.requestedQueue.length}, respQueue: ${this.respondedQueue.length}, oldReqQueueSize: ${oldReqQueueSize}, oldRespQueueSize: ${oldRespQueueSize}`);
+        //#endif
+    }
+
+    private calcFreq(window: number, q: Denque<TimedItem<any>>): number {
+        // get the frequency within the window
+        let freqCount = 0;
+        const now = Date.now();
+        for (let i = 0; i < q.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const timedItem = q.peekAt(i)!;
+            if (timedItem.timestamp > now - window * 1000) {
+                freqCount++;
+            }
+        }
+
+        const curRate = freqCount / window;
+        return curRate;
+    }
+
+    private adjustThres(reqFreq: number) {
+        // if too many requests, lower the allowReqRateThres
+        const originResThres = this.allowReqRateThres;
+        if (reqFreq > this.adjustReqRateThres) {
+            this.allowReqRateThres = Math.max(this.allowReqRateThres / 2, this.minRate)
+        } else {
+            this.allowReqRateThres = Math.min(this.allowReqRateThres * 2, this.maxRate);
+        }
+        devLog(`[Rate] reqFreq: ${reqFreq}, respRateThres: ${originResThres} -> ${this.allowReqRateThres}`)
+    }
+}