@glimt/record 0.0.64 → 0.0.66

package/dist/record.cjs

@@ -1993,16 +1993,6 @@ function serializeNodeWithId(n2, options) {
   debugging.store[n2.nodeName].push(took);
   if (debugging.index % 5e3 === 0) {
     debugging.index = 0;
-    const avgs = Object.entries(debugging.store).map(([key, values]) => {
-      return {
-        tagName: key,
-        avg: values.reduce((a2, b) => a2 + b, 0) / values.length,
-        max: Math.max(...values),
-        min: Math.min(...values)
-      };
-    });
-    console.log("last 5000 avgs");
-    console.table(avgs);
     debugging.store = {};
   }
   return serializedNode;
@@ -10337,6 +10327,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;
 }
@@ -10476,9 +10509,9 @@ class MutationBuffer {
     __publicField(this, "rollingMutTracker", {
       accumlativeMuts: 0,
       ts: -1,
-      interval: 10
+      interval: 50
     });
-    __publicField(this, "handleStormMutations", (muts) => {
+    __publicField(this, "handleStormMutations", (muts, canFinishStorm = true) => {
       const time = Date.now();
       if (this.stormInfo == null) {
         debugLog(
@@ -10504,7 +10537,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(
@@ -10543,30 +10576,20 @@ class MutationBuffer {
       }
     });
     __publicField(this, "processInternalMutations", (muts, overrideStorm = false) => {
-      console.log("muts", muts.length);
+      console.log(
+        "muts",
+        muts.length,
+        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) {