@glimt/record 0.0.69 → 0.0.71

package/dist/record.cjs

@@ -10330,9 +10330,13 @@ const stormSnapshotManager = new StormSnapshotManager();
 const _MutationRateLimiter = class _MutationRateLimiter2 {
   constructor() {
     __publicField(this, "mutTracker");
+    __publicField(this, "exitMutTracker");
     __publicField(this, "interval", 50);
-    __publicField(this, "limit", 100);
+    __publicField(this, "exitInterval", 100);
+    __publicField(this, "mutThreshold", 100);
     __publicField(this, "inGlobalStorm", false);
+    __publicField(this, "currentStormStartedAt", -1);
+    __publicField(this, "stormTimeLimit", 5e3);
     if (_MutationRateLimiter2.instance) {
       return _MutationRateLimiter2.instance;
     }
@@ -10340,24 +10344,78 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
     debugLog(`MutationRateLimiter, init`);
     this.reset();
   }
-  reset() {
+  resetTracker() {
     this.mutTracker = {
       muts: 0,
       ts: -1
     };
   }
+  resetExitTracker() {
+    this.exitMutTracker = {
+      muts: 0,
+      requested: -1
+    };
+  }
+  reset() {
+    this.resetTracker();
+    this.resetExitTracker();
+    this.currentStormStartedAt = -1;
+  }
+  stormStopped() {
+    this.inGlobalStorm = false;
+    this.reset();
+  }
+  handleStormExit(muts) {
+    const now = Date.now();
+    if (this.exitMutTracker.requested === -1) {
+      this.exitMutTracker = {
+        requested: now,
+        muts
+      };
+    } else {
+      this.exitMutTracker.muts += muts;
+      if (now - this.exitMutTracker.requested > this.exitInterval) {
+        if (this.exitMutTracker.muts >= this.mutThreshold) {
+          debugLog(
+            `MutationRateLimiter, exit cooldown failed, continuing with storm`,
+            {
+              mutTracker: this.mutTracker,
+              exitMutTracker: this.exitMutTracker
+            }
+          );
+          this.mutTracker.ts = now;
+          this.mutTracker.muts += this.exitMutTracker.muts;
+          this.resetExitTracker();
+          return true;
+        } else {
+          debugLog(`MutationRateLimiter, detected global storm exit.`, {
+            mutTracker: this.mutTracker,
+            exitMutTracker: this.exitMutTracker
+          });
+          this.stormStopped();
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  canMutationBufferExitMutationStorm() {
+    return !this.inGlobalStorm;
+  }
   isStorming(muts) {
     const now = Date.now();
     if (this.inGlobalStorm) {
-      this.mutTracker.muts += muts;
-      if (now - this.mutTracker.ts > this.interval) {
-        this.inGlobalStorm = false;
+      if (now - this.currentStormStartedAt > this.stormTimeLimit) {
         debugLog(
-          `MutationRateLimiter, detected global storm over. Total mutations stormed: ${this.mutTracker.muts}`
+          `MutationRateLimiter, storm time limit reached, stopping storm`
         );
-        this.reset();
+        this.stormStopped();
         return false;
       }
+      if (now - this.mutTracker.ts > this.interval) {
+        return this.handleStormExit(muts);
+      }
+      this.mutTracker.muts += muts;
       this.mutTracker.ts = now;
       return true;
     }
@@ -10366,9 +10424,10 @@ const _MutationRateLimiter = class _MutationRateLimiter2 {
     } else {
       if (now - this.mutTracker.ts <= this.interval) {
         this.mutTracker.muts += muts;
-        if (this.mutTracker.muts >= this.limit) {
+        if (this.mutTracker.muts >= this.mutThreshold) {
           this.inGlobalStorm = true;
           debugLog(`MutationRateLimiter, detected global rolling storm`);
+          this.currentStormStartedAt = now;
           return true;
         }
       }
@@ -10511,11 +10570,18 @@ class MutationBuffer {
     __publicField(this, "stormSettings", {
       batchSize: 50,
       //was 300
-      timeout: 30,
+      timeout: 50,
       //was 50
       mutationLimit: 800
       //was 1500
     });
+    __publicField(this, "debounceStormFinish", () => {
+      if (!this.stormInfo) return;
+      this.stormInfo.timeout = setTimeout(
+        this.handleStormFinish,
+        this.stormSettings.timeout
+      );
+    });
     __publicField(this, "handleStormMutations", (muts, canFinishStorm = true) => {
       const time = Date.now();
       if (this.stormInfo == null) {
@@ -10545,14 +10611,15 @@ class MutationBuffer {
       if (canFinishStorm && muts.length < this.stormSettings.batchSize) {
         this.handleStormFinish();
       } else {
-        this.stormInfo.timeout = setTimeout(
-          this.handleStormFinish,
-          this.stormSettings.timeout
-        );
+        this.debounceStormFinish();
       }
     });
     __publicField(this, "handleStormFinish", () => {
       if (!this.stormInfo) return;
+      if (!mutationRateLimiter.canMutationBufferExitMutationStorm()) {
+        this.debounceStormFinish();
+        return;
+      }
       const { stormExceededLimit } = this.stormInfo;
       debugLog(
         "mutation storm finished",