@glimt/record 0.0.65 → 0.0.66

package/dist/record.js

@@ -10325,6 +10325,49 @@ const _StormSnapshotManager = class _StormSnapshotManager2 {
 __publicField(_StormSnapshotManager, "instance");
 let StormSnapshotManager = _StormSnapshotManager;
 const stormSnapshotManager = new StormSnapshotManager();
+class MutationRateLimiter {
+  constructor() {
+    __publicField(this, "mutTracker");
+    __publicField(this, "interval", 50);
+    __publicField(this, "limit", 150);
+    __publicField(this, "inGlobalStorm", false);
+    debugLog(`MutationRateLimiter, init`);
+    this.reset();
+  }
+  reset() {
+    this.mutTracker = {
+      muts: 0,
+      ts: -1
+    };
+  }
+  isStorming(muts) {
+    const now = Date.now();
+    if (this.inGlobalStorm) {
+      if (now - this.mutTracker.ts > this.interval) {
+        this.inGlobalStorm = false;
+        debugLog(`MutationRateLimiter, detected global storm over`);
+        return false;
+      }
+      return true;
+    }
+    if (this.mutTracker.ts === -1) {
+      this.mutTracker.muts = muts;
+    } else {
+      if (now - this.mutTracker.ts <= this.interval) {
+        this.mutTracker.muts += muts;
+        if (this.mutTracker.muts >= this.limit) {
+          this.inGlobalStorm = true;
+          this.reset();
+          debugLog(`MutationRateLimiter, detected global rolling storm`);
+          return true;
+        }
+      }
+    }
+    this.mutTracker.ts = now;
+    return false;
+  }
+}
+const mutationRateLimiter = new MutationRateLimiter();
 function isNodeInLinkedList(n2) {
   return "__ln" in n2;
 }
@@ -10466,7 +10509,7 @@ class MutationBuffer {
       ts: -1,
       interval: 50
     });
-    __publicField(this, "handleStormMutations", (muts) => {
+    __publicField(this, "handleStormMutations", (muts, canFinishStorm = true) => {
       const time = Date.now();
       if (this.stormInfo == null) {
         debugLog(
@@ -10492,7 +10535,7 @@ class MutationBuffer {
         });
       }
       clearTimeout(this.stormInfo.timeout);
-      if (muts.length < this.stormSettings.batchSize) {
+      if (canFinishStorm && muts.length < this.stormSettings.batchSize) {
         this.handleStormFinish();
       } else {
         this.stormInfo.timeout = setTimeout(
@@ -10537,28 +10580,14 @@ class MutationBuffer {
         JSON.parse(JSON.stringify(this.rollingMutTracker))
       );
       if (!overrideStorm) {
+        const isStorming = mutationRateLimiter.isStorming(muts.length);
+        if (isStorming) {
+          this.handleStormMutations(muts, false);
+          return;
+        }
         if (this.stormInfo != null || muts.length >= this.stormSettings.batchSize) {
           this.handleStormMutations(muts);
         }
-        if (this.stormInfo == null) {
-          const now = Date.now();
-          if (this.rollingMutTracker.ts === -1) {
-            this.rollingMutTracker.accumlativeMuts = muts.length;
-          } else {
-            if (now - this.rollingMutTracker.ts <= this.rollingMutTracker.interval) {
-              this.rollingMutTracker.accumlativeMuts += muts.length;
-              if (this.rollingMutTracker.accumlativeMuts >= this.stormSettings.batchSize) {
-                debugLog(`Mutation storm through rolling detected.`);
-                this.handleStormMutations(muts);
-                this.rollingMutTracker.accumlativeMuts = 0;
-                this.rollingMutTracker.ts = -1;
-              }
-            } else {
-              this.rollingMutTracker.accumlativeMuts = 0;
-            }
-          }
-          this.rollingMutTracker.ts = now;
-        }
         return;
       }
       for (const mut of muts) {