@goodandready/dsh-key-rotation 0.8.46 → 0.8.48

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.8.48 - 2026-10-02
+
+### Fixed
+- **Debouncer Throttle Interval Preservation & Delivery Guarantee (#428)**: Ensure `AlertDebouncer.prototype.flush` respects `WebhookSender` inter-batch throttling window (`_minIntervalMs`, default 1000ms) between consecutive batch deliveries across high-burst traffic (e.g. 20 rapid exhaustion events splitting into two 10-incident batches), preventing secondary batches from receiving `throttled: true` drops and guaranteeing all accepted digest alerts are delivered without loss.
+
+## 0.8.47 - 2026-10-02
+
+### Fixed
+- **Pool Exhaustion Alerts Coalescing into Digest (#428)**: Pass hooks (`webhookSender`, `notifyQueue`, `now`) to `notifyExhaustion` in `createRotate` options in `lib/index.js`, ensuring rapid multi-pool exhaustions route through `NotifyQueue` and `AlertDebouncer` into a single consolidated digest rather than falling back to default direct sender where secondary alerts get dropped by the 1-req/s throttle.
+- **Queue Admission Bound & Debouncer Send Serialization (#435)**: Track unsettled events (`_unsettled`) in `NotifyQueue` across debounced send lifecycles to strictly enforce admission limit (`maxDepth`) during burst traffic without bypassing queue capacity, and serialize batched HTTP deliveries in `AlertDebouncer.prototype.flush` via `_sendLock` to ensure single-flight send concurrency (`peak <= 1`).
+
 ## 0.8.46 - 2026-10-02
 
 ### Fixed

package/lib/index.js

@@ -409,7 +409,7 @@ export function apply(ctx, config = {}) {
     schedulePersist,
     pushEvent,
     notifySwitch: (runtime, pool, info) => notifySwitch(runtime, pool, info, { webhookSender, notifyQueue: moduleNotifyQueue, now: () => Date.now() }),
-    notifyExhaustion,
+    notifyExhaustion: (runtime, pool, options) => notifyExhaustion(runtime, pool, options, { webhookSender, notifyQueue: moduleNotifyQueue, now: () => Date.now() }),
     recordLatency,
     latencyHistogram,
     concurrencyTracker,

package/lib/notify-queue.js

@@ -14,6 +14,7 @@ export class NotifyQueue {
     this._q = [];
     this._busy = false;
     this._activeSends = 0;
+    this._unsettled = 0;
     this._backoffByUrl = new Map();
     this._dropped = 0;
     this._sent = 0;
@@ -22,10 +23,11 @@ export class NotifyQueue {
 
   enqueue(url, payload) {
     if (!url) return { queued: false, reason: "no-url" };
-    if (this._q.length >= this.maxDepth) {
+    if (this._unsettled >= this.maxDepth + 1 || this._q.length >= this.maxDepth) {
       this._dropped += 1;
       return { queued: false, reason: "full", dropped: this._dropped };
     }
+    this._unsettled += 1;
     this._q.push({ url, payload });
     this._pump();
     return { queued: true };
@@ -67,6 +69,7 @@ export class NotifyQueue {
         this._failed += 1;
         this._bumpBackoff(job.url);
       } finally {
+        this._unsettled = Math.max(0, this._unsettled - 1);
         if (!sendPromise || !sendPromise.debounced) {
           this._busy = false;
           this._activeSends = 0;
@@ -91,6 +94,12 @@ export class NotifyQueue {
   }
 
   stats() {
-    return { depth: this._q.length, dropped: this._dropped, sent: this._sent, failed: this._failed, busy: this._busy };
+    return {
+      depth: this._q.length,
+      dropped: this._dropped,
+      sent: this._sent,
+      failed: this._failed,
+      busy: this._busy || this._activeSends > 0 || (this._unsettled >= this.maxDepth + 1)
+    };
   }
 }

package/lib/webhook.js

@@ -264,10 +264,34 @@ export class AlertDebouncer {
       };
     }
 
-    const res = await this._sender.send(url, payload);
-    for (const cb of entry.callbacks) {
-      bestEffort('webhook.callback', () => { cb(res); }, this._logger);
-    }
-    return res;
+    const sendBatch = async () => {
+      if (this._sender && typeof this._sender._lastSentAt?.get === 'function') {
+        const last = this._sender._lastSentAt.get(url);
+        const minInterval = Number.isFinite(this._sender._minIntervalMs) ? this._sender._minIntervalMs : 1000;
+        if (Number.isFinite(last)) {
+          const elapsed = Date.now() - last;
+          if (elapsed < minInterval) {
+            await new Promise((r) => setTimeout(r, minInterval - elapsed + 20));
+          }
+        }
+      }
+      let res = await this._sender.send(url, payload);
+      while (res && res.throttled) {
+        const last = (this._sender && typeof this._sender._lastSentAt?.get === 'function')
+          ? this._sender._lastSentAt.get(url) : null;
+        const minInterval = (this._sender && this._sender._minIntervalMs) || 1000;
+        const now = Date.now();
+        const wait = Number.isFinite(last) ? Math.max(50, minInterval - (now - last) + 20) : minInterval;
+        await new Promise((r) => setTimeout(r, wait));
+        res = await this._sender.send(url, payload);
+      }
+      for (const cb of entry.callbacks) {
+        bestEffort('webhook.callback', () => { cb(res); }, this._logger);
+      }
+      return res;
+    };
+
+    this._sendLock = (this._sendLock || Promise.resolve()).then(sendBatch, sendBatch);
+    return this._sendLock;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-key-rotation",
-  "version": "0.8.46",
+  "version": "0.8.48",
   "packageManager": "pnpm@10.33.2",
   "description": "Per-provider API key rotation for DeepSeek Harness: a key pool per provider, auto-created clone routes, and switching to the next key on quota/rate-limit errors. Includes a Settings section (Key Rotation) to edit the key pools, cooldown and switch codes.",
   "keywords": [