adaptive-concurrency 0.10.0 → 0.10.1

package/dist/limit/AIMDLimit.d.ts

@@ -17,6 +17,16 @@ export interface AIMDLimitOptions {
      * Default: 5000
      */
     timeout?: number;
+    /**
+     * Absolute amount to use as a +/- jitter band around `backoffRatio` for
+     * each multiplicative decrease. Breaks lockstep oscillation when multiple
+     * independent clients share the same configuration.
+     *
+     * For example, with `backoffRatio: 0.9` and `backoffJitter: 0.02`, each
+     * decrease multiplies by a uniformly random value in [0.88, 0.92].
+     * Must be in [0, 0.05]. Default: 0.02.
+     */
+    backoffJitter?: number;
 }
 export declare class AIMDLimit implements AdaptiveLimit {
     private _limit;
@@ -25,6 +35,7 @@ export declare class AIMDLimit implements AdaptiveLimit {
     private readonly timeout;
     private readonly minLimit;
     private readonly maxLimit;
+    private readonly backoffJitter;
     constructor(options?: AIMDLimitOptions);
     addSample(_startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
     get currentLimit(): number;

package/dist/limit/AIMDLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AIMDLimit.d.ts","sourceRoot":"","sources":["../../src/limit/AIMDLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,SAAU,YAAW,aAAa;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,OAAO,GAAE,gBAAqB;IAiB1C,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAapF,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"AIMDLimit.d.ts","sourceRoot":"","sources":["../../src/limit/AIMDLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;OAQG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,SAAU,YAAW,aAAa;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,OAAO,GAAE,gBAAqB;IA0B1C,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAuBP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/limit/AIMDLimit.js

@@ -6,6 +6,7 @@ export class AIMDLimit {
     timeout;
     minLimit;
     maxLimit;
+    backoffJitter;
     constructor(options = {}) {
         const initialLimit = options.initialLimit ?? 20;
         this._limit = initialLimit;
@@ -13,19 +14,27 @@ export class AIMDLimit {
         this.timeout = options.timeout ?? 5_000;
         this.minLimit = options.minLimit ?? 20;
         this.maxLimit = options.maxLimit ?? 200;
+        this.backoffJitter = options.backoffJitter ?? 0.02;
         if (this.backoffRatio >= 1.0 || this.backoffRatio < 0.5) {
             throw new Error("Backoff ratio must be in the range [0.5, 1.0)");
         }
         if (this.timeout <= 0) {
             throw new Error("Timeout must be positive");
         }
+        if (this.backoffJitter < 0 || this.backoffJitter > 0.05) {
+            throw new Error("backoffJitter must be in the range [0, 0.05]");
+        }
+        if (this.backoffRatio + this.backoffJitter >= 1.0) {
+            throw new Error("backoffRatio + backoffJitter must be < 1.0 to guarantee the limit decreases on drop");
+        }
     }
     addSample(_startTime, rtt, inflight, didDrop) {
         let currentLimit = this._limit;
         if (didDrop || rtt > this.timeout) {
-            currentLimit = Math.floor(currentLimit * this.backoffRatio);
+            const jitteredRatio = Math.max(0.5, Math.min(1 - Number.EPSILON, this.backoffRatio + (Math.random() * 2 - 1) * this.backoffJitter));
+            currentLimit = Math.floor(currentLimit * jitteredRatio);
         }
-        else if (inflight * 2 >= currentLimit) {
+        else if (inflight >= 0.5 * currentLimit) {
             currentLimit = currentLimit + 1;
         }
         const newLimit = Math.min(this.maxLimit, Math.max(this.minLimit, currentLimit));

package/dist/limit/OperationGroupedLimit.d.ts

@@ -0,0 +1,78 @@
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Decorator that normalizes RTT samples by operation group before forwarding
+ * them to a delegate {@link AdaptiveLimit}.
+ *
+ * When a single limiter covers heterogeneous operations (e.g. fast reads and
+ * slow writes), raw RTT variance can reflect the **operation mix** rather than
+ * downstream congestion. A shift toward slower operations looks like a latency
+ * spike and causes the delegate to needlessly reduce the limit.
+ *
+ * `OperationGroupedLimit` solves this by maintaining a per-group RTT baseline
+ * (exponential moving average with a long window). Each sample's RTT is
+ * expressed as a ratio relative to its group's own baseline, then scaled by a
+ * fixed reference value:
+ *
+ *     normalizedRtt = (rtt / groupBaseline) × referenceRtt
+ *
+ * `referenceRtt` is a constant configured at construction time (derived from
+ * the first group's baseline after warmup if not explicitly provided). Because
+ * it never changes, a shift in operation mix cannot cause a spurious RTT spike.
+ * Meanwhile, real congestion within any group shows through because it causes
+ * `rtt / groupBaseline > 1`.
+ *
+ * Per-group baselines use a long EMA window so they represent the group's
+ * **intrinsic** latency characteristic and don't absorb short-term congestion.
+ *
+ * The `groupFor` function maps each sample to a group key. Samples whose group
+ * cannot be determined (returns `undefined`) are forwarded with their raw RTT.
+ */
+export declare class OperationGroupedLimit implements AdaptiveLimit {
+    private readonly delegate;
+    private readonly groupFor;
+    private readonly groups;
+    private readonly groupWindow;
+    private readonly groupWarmup;
+    /**
+     * Fixed reference RTT used as the absolute scale for normalized values.
+     * Once set, it never changes, ensuring mix shifts don't affect normalization.
+     * `undefined` until enough samples have been seen to establish it.
+     */
+    private referenceRtt;
+    private readonly configuredReferenceRtt;
+    constructor(delegate: AdaptiveLimit, options: {
+        /**
+         * Maps a sample's `startTime` to its operation group key.
+         *
+         * In practice, the caller records the group when acquiring a limiter
+         * allotment (at which point `startTime` is captured by the `Limiter`),
+         * then provides a lookup here that resolves that `startTime` back to the
+         * group. Returning `undefined` forwards the sample unnormalized.
+         */
+        groupFor: (startTime: number) => string | undefined;
+        /**
+         * EMA window size for per-group RTT baselines. These should be long
+         * enough to represent the group's intrinsic latency so short-term
+         * congestion shows through as deviations. Default: 500
+         */
+        groupWindow?: number;
+        /**
+         * Number of initial samples averaged arithmetically before switching to
+         * exponential decay (per-group). Default: 10
+         */
+        groupWarmup?: number;
+        /**
+         * Fixed reference RTT (in milliseconds) used as the scale for all
+         * normalized values. If not provided, it is automatically set from the
+         * first group's baseline after its warmup phase completes.
+         */
+        referenceRtt?: number;
+    });
+    addSample(startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+    get currentLimit(): number;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    toString(): string;
+}
+//# sourceMappingURL=OperationGroupedLimit.d.ts.map

package/dist/limit/OperationGroupedLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationGroupedLimit.d.ts","sourceRoot":"","sources":["../../src/limit/OperationGroupedLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4C;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAqB;gBAG1D,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE;QACP;;;;;;;WAOG;QACH,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;QAEpD;;;;WAIG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB;;;;WAIG;QACH,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;IAUH,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAqCP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,MAAM,IAAI;IAIb,QAAQ,IAAI,MAAM;CAOnB"}

package/dist/limit/OperationGroupedLimit.js

@@ -0,0 +1,93 @@
+import { ExpMovingAverage } from "../statistics/ExpMovingAverage.js";
+/**
+ * Decorator that normalizes RTT samples by operation group before forwarding
+ * them to a delegate {@link AdaptiveLimit}.
+ *
+ * When a single limiter covers heterogeneous operations (e.g. fast reads and
+ * slow writes), raw RTT variance can reflect the **operation mix** rather than
+ * downstream congestion. A shift toward slower operations looks like a latency
+ * spike and causes the delegate to needlessly reduce the limit.
+ *
+ * `OperationGroupedLimit` solves this by maintaining a per-group RTT baseline
+ * (exponential moving average with a long window). Each sample's RTT is
+ * expressed as a ratio relative to its group's own baseline, then scaled by a
+ * fixed reference value:
+ *
+ *     normalizedRtt = (rtt / groupBaseline) × referenceRtt
+ *
+ * `referenceRtt` is a constant configured at construction time (derived from
+ * the first group's baseline after warmup if not explicitly provided). Because
+ * it never changes, a shift in operation mix cannot cause a spurious RTT spike.
+ * Meanwhile, real congestion within any group shows through because it causes
+ * `rtt / groupBaseline > 1`.
+ *
+ * Per-group baselines use a long EMA window so they represent the group's
+ * **intrinsic** latency characteristic and don't absorb short-term congestion.
+ *
+ * The `groupFor` function maps each sample to a group key. Samples whose group
+ * cannot be determined (returns `undefined`) are forwarded with their raw RTT.
+ */
+export class OperationGroupedLimit {
+    delegate;
+    groupFor;
+    groups = new Map();
+    groupWindow;
+    groupWarmup;
+    /**
+     * Fixed reference RTT used as the absolute scale for normalized values.
+     * Once set, it never changes, ensuring mix shifts don't affect normalization.
+     * `undefined` until enough samples have been seen to establish it.
+     */
+    referenceRtt;
+    configuredReferenceRtt;
+    constructor(delegate, options) {
+        this.delegate = delegate;
+        this.groupFor = options.groupFor;
+        this.groupWindow = options.groupWindow ?? 500;
+        this.groupWarmup = options.groupWarmup ?? 10;
+        this.configuredReferenceRtt = options.referenceRtt;
+        this.referenceRtt = options.referenceRtt;
+    }
+    addSample(startTime, rtt, inflight, didDrop) {
+        const group = this.groupFor(startTime);
+        if (group === undefined) {
+            this.delegate.addSample(startTime, rtt, inflight, didDrop);
+            return;
+        }
+        let groupEma = this.groups.get(group);
+        let isNew = false;
+        if (!groupEma) {
+            groupEma = new ExpMovingAverage(this.groupWindow, this.groupWarmup);
+            this.groups.set(group, groupEma);
+            isNew = true;
+        }
+        // Read the group baseline *before* incorporating this sample so that the
+        // current observation doesn't immediately anchor its own normalization.
+        const prevGroupBaseline = groupEma.currentValue;
+        groupEma.addSample(rtt);
+        // Auto-detect the reference RTT from the first group's baseline once its
+        // warmup is complete.
+        if (this.referenceRtt === undefined && !isNew && prevGroupBaseline > 0) {
+            this.referenceRtt = prevGroupBaseline;
+        }
+        let normalizedRtt;
+        if (prevGroupBaseline <= 0 || this.referenceRtt === undefined) {
+            normalizedRtt = rtt;
+        }
+        else {
+            normalizedRtt = (rtt / prevGroupBaseline) * this.referenceRtt;
+        }
+        this.delegate.addSample(startTime, normalizedRtt, inflight, didDrop);
+    }
+    get currentLimit() {
+        return this.delegate.currentLimit;
+    }
+    subscribe(consumer, options) {
+        return this.delegate.subscribe(consumer, options);
+    }
+    toString() {
+        return (`OperationGroupedLimit [groups=${this.groups.size}` +
+            `, referenceRtt=${this.referenceRtt?.toFixed(3) ?? "pending"}` +
+            `, delegate=${this.delegate}]`);
+    }
+}

package/dist/limit/VegasLimit.d.ts

@@ -43,9 +43,10 @@ export interface VegasLimitOptions {
          */
         increase?(limit: number): number;
         /**
-         * Compute the new limit when decreasing.
+         * Compute the new limit when decreasing. If didDrop is true, decrease() is
+         * being called because of a drop.
          */
-        decrease?(limit: number): number;
+        decrease?(limit: number, didDrop: boolean): number;
     };
     /**
      * The limiter will probe for a new noload RTT every
@@ -66,9 +67,9 @@ export declare class VegasLimit implements AdaptiveLimit {
     private readonly smoothing;
     private readonly policy;
     private readonly rttSampleListener;
-    private readonly probeMultiplier;
     private probeCount;
     private probeJitter;
+    private readonly probeMultiplier;
     constructor(options?: VegasLimitOptions);
     private resetProbeJitter;
     private shouldProbe;

package/dist/limit/VegasLimit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VegasLimit.d.ts","sourceRoot":"","sources":["../../src/limit/VegasLimit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAezD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP;;;;WAIG;QACH,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE9B;;;;WAIG;QACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE7B;;WAEG;QACH,SAAS,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAElC;;WAEG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAEjC;;WAEG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;KAClC,CAAC;IAEF;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;AAElF,qBAAa,UAAW,YAAW,aAAa;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,SAAS,CAAK;IAEtB,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IACvD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,iBAAsB;IAuB3C,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,WAAW;IAInB,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAIP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,OAAO,CAAC,gBAAgB;IA6BxB,OAAO,CAAC,oBAAoB;IA0C5B,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"VegasLimit.d.ts","sourceRoot":"","sources":["../../src/limit/VegasLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAezD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP;;;;WAIG;QACH,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE9B;;;;WAIG;QACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAE7B;;WAEG;QACH,SAAS,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAElC;;WAEG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QAEjC;;;WAGG;QACH,QAAQ,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;KACpD,CAAC;IAEF;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CACrC,WAAW,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CACzC,CAAC;AAEF,qBAAa,UAAW,YAAW,aAAa;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,SAAS,CAAK;IAEtB,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IAEvD,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;gBAE7B,OAAO,GAAE,iBAAsB;IAyB3C,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,WAAW;IAOnB,SAAS,CACP,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,IAAI;IAMP,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,OAAO,CAAC,aAAa;IAOrB,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAO,GACrC,MAAM,IAAI;IAIb,OAAO,CAAC,gBAAgB;IA+BxB,OAAO,CAAC,oBAAoB;IA2C5B,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/limit/VegasLimit.js

@@ -1,6 +1,5 @@
 import { ListenerSet } from "../ListenerSet.js";
-import { MetricIds } from "../MetricRegistry.js";
-import { NoopMetricRegistry } from "../MetricRegistry.js";
+import { MetricIds, NoopMetricRegistry } from "../MetricRegistry.js";
 /**
  * Sublinear scale of the concurrency limit (floor of log10, lower-bounded for
  * small n). Same idea as Netflix's Log10RootIntFunction. Used only for
@@ -21,9 +20,9 @@ export class VegasLimit {
     smoothing;
     policy;
     rttSampleListener;
-    probeMultiplier;
     probeCount = 0;
     probeJitter;
+    probeMultiplier;
     constructor(options = {}) {
         const initialLimit = options.initialLimit ?? 20;
         this._limit = initialLimit;
@@ -47,7 +46,8 @@ export class VegasLimit {
         return this.probeJitter;
     }
     shouldProbe() {
-        return this.probeJitter * this.probeMultiplier * this.estimatedLimit <= this.probeCount;
+        return (this.probeJitter * this.probeMultiplier * this.estimatedLimit <=
+            this.probeCount);
     }
     addSample(startTime, rtt, inflight, didDrop) {
         this.applyNewLimit(this.computeNextLimit(startTime, rtt, inflight, didDrop));
@@ -73,11 +73,13 @@ export class VegasLimit {
             this.resetProbeJitter();
             this.probeCount = 0;
             this.rttNoload = rtt;
+            this.rttSampleListener.addSample(rtt);
             return Math.floor(this.estimatedLimit);
         }
         const rttNoload = this.rttNoload;
         if (rttNoload === 0 || rtt < rttNoload) {
             this.rttNoload = rtt;
+            this.rttSampleListener.addSample(rtt);
             return Math.floor(this.estimatedLimit);
         }
         this.rttSampleListener.addSample(rttNoload);
@@ -89,7 +91,7 @@ export class VegasLimit {
         let newLimit;
         // Treat any drop (i.e timeout) as needing to reduce the limit
         if (didDrop) {
-            newLimit = this.policy.decrease(estimatedLimit);
+            newLimit = this.policy.decrease(estimatedLimit, didDrop);
             // Prevent upward drift if not close to the limit
         }
         else if (inflight * 2 < estimatedLimit) {
@@ -109,7 +111,7 @@ export class VegasLimit {
                 // Detecting latency so decrease
             }
             else if (queueSize > beta) {
-                newLimit = this.policy.decrease(estimatedLimit);
+                newLimit = this.policy.decrease(estimatedLimit, didDrop);
                 // We're within the sweet spot so nothing to do
             }
             else {
@@ -117,7 +119,8 @@ export class VegasLimit {
             }
         }
         newLimit = Math.max(1, Math.min(this.maxLimit, newLimit));
-        newLimit = (1 - this.smoothing) * estimatedLimit + this.smoothing * newLimit;
+        newLimit =
+            (1 - this.smoothing) * estimatedLimit + this.smoothing * newLimit;
         this.estimatedLimit = newLimit;
         return Math.floor(newLimit);
     }

package/package.json

@@ -9,7 +9,7 @@
     "dynamic rate limiting"
   ],
   "author": "Ethan Resnick <ethan.resnick@gmail.com>",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "type": "module",
   "exports": {
     ".": {