adaptive-concurrency 0.1.0

package/dist/limit/Gradient2Limit.js

@@ -0,0 +1,107 @@
+import { ListenerSet } from "../ListenerSet.js";
+import { MetricIds } from "../MetricIds.js";
+import { NoopMetricRegistry } from "../MetricRegistry.js";
+import { ExpMovingAverage } from "../statistics/ExpMovingAverage.js";
+export class Gradient2Limit {
+    _limit;
+    limitListeners = new ListenerSet();
+    /** Estimated concurrency limit based on our algorithm */
+    estimatedLimit;
+    /**
+     * Tracks a measurement of the short time, and more volatile, RTT meant to
+     * represent the current system latency.
+     */
+    lastRtt = 0;
+    /**
+     * Tracks a measurement of the long term, less volatile, RTT meant to
+     * represent the baseline latency. When the system is under load this number
+     * is expected to trend higher.
+     */
+    longRtt;
+    /** Maximum allowed limit providing an upper bound failsafe */
+    maxLimit;
+    minLimit;
+    queueSize;
+    smoothing;
+    tolerance;
+    longRttSampleListener;
+    shortRttSampleListener;
+    queueSizeSampleListener;
+    constructor(options = {}) {
+        const initialLimit = options.initialLimit ?? 20;
+        this._limit = initialLimit;
+        this.estimatedLimit = initialLimit;
+        this.maxLimit = options.maxConcurrency ?? 200;
+        this.minLimit = options.minLimit ?? 20;
+        this.smoothing = options.smoothing ?? 0.2;
+        this.tolerance = options.rttTolerance ?? 1.5;
+        this.longRtt = new ExpMovingAverage(options.longWindow ?? 600, 10);
+        if (options.rttTolerance !== undefined && options.rttTolerance < 1.0) {
+            throw new Error("Tolerance must be >= 1.0");
+        }
+        const qs = options.queueSize ?? 4;
+        this.queueSize = typeof qs === "number" ? () => qs : qs;
+        const registry = options.metricRegistry ?? NoopMetricRegistry;
+        this.longRttSampleListener = registry.distribution(MetricIds.MIN_RTT_NAME);
+        this.shortRttSampleListener = registry.distribution(MetricIds.WINDOW_MIN_RTT_NAME);
+        this.queueSizeSampleListener = registry.distribution(MetricIds.WINDOW_QUEUE_SIZE_NAME);
+    }
+    addSample(_startTime, rtt, inflight, _didDrop) {
+        const newLimitNoFloor = this.computeNextLimitUnrounded(rtt, inflight);
+        this.estimatedLimit = newLimitNoFloor;
+        const newLimit = Math.floor(newLimitNoFloor);
+        this.applyNewLimit(newLimit);
+    }
+    get currentLimit() {
+        return this._limit;
+    }
+    applyNewLimit(newLimit) {
+        if (newLimit !== this._limit) {
+            this._limit = newLimit;
+            this.limitListeners.notify(newLimit);
+        }
+    }
+    subscribe(consumer, options = {}) {
+        return this.limitListeners.subscribe(consumer, options);
+    }
+    computeNextLimitUnrounded(rtt, inflight) {
+        let estimatedLimit = this.estimatedLimit;
+        const queueSize = this.queueSize(Math.floor(estimatedLimit));
+        this.lastRtt = rtt;
+        const shortRtt = rtt;
+        const longRtt = this.longRtt.addSample(rtt);
+        this.shortRttSampleListener.addSample(shortRtt);
+        this.longRttSampleListener.addSample(longRtt);
+        this.queueSizeSampleListener.addSample(queueSize);
+        // If the long RTT is substantially larger than the short RTT then reduce
+        // the long RTT measurement. This can happen when latency returns to normal
+        // after a prolonged period of excessive load. Reducing the long RTT without
+        // waiting for the exponential smoothing helps bring the system back to
+        // steady state.
+        if (longRtt / shortRtt > 2) {
+            this.longRtt.update((current) => current * 0.95);
+        }
+        // Don't grow the limit if we are app limited
+        if (inflight < estimatedLimit / 2) {
+            return estimatedLimit;
+        }
+        // Rtt could be higher than rtt_noload because of smoothing rtt noload
+        // updates so set to 1.0 to indicate no queuing. Otherwise calculate the
+        // slope and don't allow it to be reduced by more than half to avoid
+        // aggressive load-shedding due to outliers.
+        const gradient = Math.max(0.5, Math.min(1.0, this.tolerance * longRtt / shortRtt));
+        let newLimit = estimatedLimit * gradient + queueSize;
+        newLimit = estimatedLimit * (1 - this.smoothing) + newLimit * this.smoothing;
+        newLimit = Math.max(this.minLimit, Math.min(this.maxLimit, newLimit));
+        return newLimit;
+    }
+    getLastRtt() {
+        return this.lastRtt;
+    }
+    getRttNoLoad() {
+        return this.longRtt.currentValue;
+    }
+    toString() {
+        return `Gradient2Limit [limit=${Math.floor(this.estimatedLimit)}]`;
+    }
+}

package/dist/limit/GradientLimit.d.ts

@@ -0,0 +1,122 @@
+import type { MetricRegistry } from "../MetricRegistry.js";
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Concurrency limit algorithm that adjusts the limit based on the gradient of
+ * change of the current average RTT and a long term exponentially smoothed
+ * average RTT. Unlike traditional congestion control algorithms we use average
+ * instead of minimum since RPC methods can be very bursty due to various
+ * factors such as non-homogenous request processing complexity as well as a
+ * wide distribution of data size. We have also found that using minimum can
+ * result in a bias towards an impractically low base RTT resulting in excessive
+ * load shedding. An exponential decay is applied to the base RTT so that the
+ * value is kept stable yet is allowed to adapt to long term changes in latency
+ * characteristics.
+ *
+ * The core algorithm re-calculates the limit every sampling window
+ * (e.g. 1 second) using the formula:
+ *
+ *   // Calculate the gradient limiting to the range [0.5, 1.0] to filter outliers
+ *   gradient = max(0.5, min(1.0, longtermRtt / currentRtt));
+ *
+ *   // Calculate the new limit by applying the gradient and allowing for some queuing
+ *   newLimit = gradient * currentLimit + queueSize;
+ *
+ *   // Update the limit using a smoothing factor (default 0.2)
+ *   newLimit = currentLimit * (1 - smoothing) + newLimit * smoothing
+ *
+ * The limit can be in one of three main states:
+ *
+ * 1. Steady state
+ *    The average RTT is very stable and the current measurement whipsaws around
+ *    this value, sometimes reducing the limit, sometimes increasing it.
+ *
+ * 2. Transition from steady state to load
+ *    Either the RPS or latency has spiked. The gradient is < 1.0 due to a
+ *    growing request queue that cannot be handled by the system. Excessive
+ *    requests are rejected due to the low limit. The baseline RTT grows using
+ *    exponential decay but lags the current measurement, which keeps the
+ *    gradient < 1.0 and limit low.
+ *
+ * 3. Transition from load to steady state
+ *    The system goes back to steady state after a prolonged period of excessive
+ *    load. Requests aren't rejected and the sample RTT remains low. During this
+ *    state the long term RTT may take some time to go back to normal and could
+ *    potentially be several multiples higher than the current RTT.
+ */
+export interface Gradient2LimitOptions {
+    /** Initial limit used by the limiter. Default: 20 */
+    initialLimit?: number;
+    /**
+     * Minimum concurrency limit allowed. The minimum helps prevent the algorithm
+     * from adjusting the limit too far down. Note that this limit is not
+     * desirable when used as backpressure for batch apps. Default: 20
+     */
+    minLimit?: number;
+    /**
+     * Maximum allowable concurrency. Any estimated concurrency will be capped at
+     * this value. Default: 200
+     */
+    maxConcurrency?: number;
+    /**
+     * Smoothing factor to limit how aggressively the estimated limit can shrink
+     * when queuing has been detected. Value of 0.0 to 1.0 where 1.0 means the
+     * limit is completely replaced by the new estimate. Default: 0.2
+     */
+    smoothing?: number;
+    /**
+     * Fixed amount the estimated limit can grow while latencies remain low.
+     * Can be a constant or a function of the current limit. Default: 4
+     */
+    queueSize?: number | ((concurrency: number) => number);
+    /**
+     * Tolerance for changes in minimum latency. Value >= 1.0 indicating how
+     * much change in minimum latency is acceptable before reducing the limit.
+     * For example, a value of 2.0 means that a 2x increase in latency is
+     * acceptable. Default: 1.5
+     */
+    rttTolerance?: number;
+    /**
+     * Number of samples in the long-term exponential average window.
+     * Default: 600
+     */
+    longWindow?: number;
+    metricRegistry?: MetricRegistry;
+}
+export declare class GradientLimit implements AdaptiveLimit {
+    private _limit;
+    private readonly limitListeners;
+    /** Estimated concurrency limit based on our algorithm */
+    private estimatedLimit;
+    /**
+     * Tracks a measurement of the short time, and more volatile, RTT meant to
+     * represent the current system latency.
+     */
+    private lastRtt;
+    /**
+     * Tracks a measurement of the long term, less volatile, RTT meant to
+     * represent the baseline latency. When the system is under load this number
+     * is expected to trend higher.
+     */
+    private readonly longRtt;
+    /** Maximum allowed limit providing an upper bound failsafe */
+    private readonly maxLimit;
+    private readonly minLimit;
+    private readonly queueSize;
+    private readonly smoothing;
+    private readonly tolerance;
+    private readonly longRttSampleListener;
+    private readonly shortRttSampleListener;
+    private readonly queueSizeSampleListener;
+    constructor(options?: Gradient2LimitOptions);
+    addSample(_startTime: number, rtt: number, inflight: number, _didDrop: boolean): void;
+    get currentLimit(): number;
+    private applyNewLimit;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    private computeNextLimitUnrounded;
+    getLastRtt(): number;
+    getRttNoLoad(): number;
+    toString(): string;
+}
+//# sourceMappingURL=GradientLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GradientLimit.d.ts","sourceRoot":"","sources":["../../src/limit/GradientLimit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAI/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,WAAW,qBAAqB;IACpC,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAEvD;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,yDAAyD;IACzD,OAAO,CAAC,cAAc,CAAS;IAE/B;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAK;IAEpB;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;IAC5D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IAEnC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAqB;IAC3D,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAqB;IAC5D,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAqB;gBAEjD,OAAO,GAAE,qBAA0B;IA4B/C,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,OAAO,GAChB,IAAI;IASP,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,yBAAyB;IA0CjC,UAAU,IAAI,MAAM;IAIpB,YAAY,IAAI,MAAM;IAItB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/limit/GradientLimit.js

@@ -0,0 +1,108 @@
+import { ListenerSet } from "../ListenerSet.js";
+import { MetricIds } from "../MetricRegistry.js";
+import { NoopMetricRegistry } from "../MetricRegistry.js";
+import { ExpMovingAverage } from "../statistics/ExpMovingAverage.js";
+export class GradientLimit {
+    _limit;
+    limitListeners = new ListenerSet();
+    /** Estimated concurrency limit based on our algorithm */
+    estimatedLimit;
+    /**
+     * Tracks a measurement of the short time, and more volatile, RTT meant to
+     * represent the current system latency.
+     */
+    lastRtt = 0;
+    /**
+     * Tracks a measurement of the long term, less volatile, RTT meant to
+     * represent the baseline latency. When the system is under load this number
+     * is expected to trend higher.
+     */
+    longRtt;
+    /** Maximum allowed limit providing an upper bound failsafe */
+    maxLimit;
+    minLimit;
+    queueSize;
+    smoothing;
+    tolerance;
+    longRttSampleListener;
+    shortRttSampleListener;
+    queueSizeSampleListener;
+    constructor(options = {}) {
+        const initialLimit = options.initialLimit ?? 20;
+        this._limit = initialLimit;
+        this.estimatedLimit = initialLimit;
+        this.maxLimit = options.maxConcurrency ?? 200;
+        this.minLimit = options.minLimit ?? 20;
+        this.smoothing = options.smoothing ?? 0.2;
+        this.tolerance = options.rttTolerance ?? 1.5;
+        this.longRtt = new ExpMovingAverage(options.longWindow ?? 600, 10);
+        if (options.rttTolerance !== undefined && options.rttTolerance < 1.0) {
+            throw new Error("Tolerance must be >= 1.0");
+        }
+        const qs = options.queueSize ?? 4;
+        this.queueSize = typeof qs === "number" ? () => qs : qs;
+        const registry = options.metricRegistry ?? NoopMetricRegistry;
+        this.longRttSampleListener = registry.distribution(MetricIds.MIN_RTT_NAME);
+        this.shortRttSampleListener = registry.distribution(MetricIds.WINDOW_MIN_RTT_NAME);
+        this.queueSizeSampleListener = registry.distribution(MetricIds.WINDOW_QUEUE_SIZE_NAME);
+    }
+    addSample(_startTime, rtt, inflight, _didDrop) {
+        const newLimitNoFloor = this.computeNextLimitUnrounded(rtt, inflight);
+        this.estimatedLimit = newLimitNoFloor;
+        const newLimit = Math.floor(newLimitNoFloor);
+        this.applyNewLimit(newLimit);
+    }
+    get currentLimit() {
+        return this._limit;
+    }
+    applyNewLimit(newLimit) {
+        if (newLimit !== this._limit) {
+            this._limit = newLimit;
+            this.limitListeners.notify(newLimit);
+        }
+    }
+    subscribe(consumer, options = {}) {
+        return this.limitListeners.subscribe(consumer, options);
+    }
+    computeNextLimitUnrounded(rtt, inflight) {
+        let estimatedLimit = this.estimatedLimit;
+        const queueSize = this.queueSize(Math.floor(estimatedLimit));
+        this.lastRtt = rtt;
+        const shortRtt = rtt;
+        const longRtt = this.longRtt.addSample(rtt);
+        this.shortRttSampleListener.addSample(shortRtt);
+        this.longRttSampleListener.addSample(longRtt);
+        this.queueSizeSampleListener.addSample(queueSize);
+        // If the long RTT is substantially larger than the short RTT then reduce
+        // the long RTT measurement. This can happen when latency returns to normal
+        // after a prolonged period of excessive load. Reducing the long RTT without
+        // waiting for the exponential smoothing helps bring the system back to
+        // steady state.
+        if (longRtt / shortRtt > 2) {
+            this.longRtt.update((current) => current * 0.95);
+        }
+        // Don't grow the limit if we are app limited
+        if (inflight < estimatedLimit / 2) {
+            return estimatedLimit;
+        }
+        // Rtt could be higher than rtt_noload because of smoothing rtt noload
+        // updates so set to 1.0 to indicate no queuing. Otherwise calculate the
+        // slope and don't allow it to be reduced by more than half to avoid
+        // aggressive load-shedding due to outliers.
+        const gradient = Math.max(0.5, Math.min(1.0, (this.tolerance * longRtt) / shortRtt));
+        let newLimit = estimatedLimit * gradient + queueSize;
+        newLimit =
+            estimatedLimit * (1 - this.smoothing) + newLimit * this.smoothing;
+        newLimit = Math.max(this.minLimit, Math.min(this.maxLimit, newLimit));
+        return newLimit;
+    }
+    getLastRtt() {
+        return this.lastRtt;
+    }
+    getRttNoLoad() {
+        return this.longRtt.currentValue;
+    }
+    toString() {
+        return `Gradient2Limit [limit=${Math.floor(this.estimatedLimit)}]`;
+    }
+}

package/dist/limit/SettableLimit.d.ts

@@ -0,0 +1,18 @@
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Limit to be used mostly for testing where the limit can be manually
+ * adjusted.
+ */
+export declare class SettableLimit implements AdaptiveLimit {
+    private _limit;
+    private readonly limitListeners;
+    constructor(limit: number);
+    get currentLimit(): number;
+    addSample(_startTime: number, _rtt: number, _inflight: number, _didDrop: boolean): void;
+    setLimit(limit: number): void;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    toString(): string;
+}
+//# sourceMappingURL=SettableLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SettableLimit.d.ts","sourceRoot":"","sources":["../../src/limit/SettableLimit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiD;gBAEpE,KAAK,EAAE,MAAM;IAIzB,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,SAAS,CACP,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,OAAO,GAChB,IAAI;IAIP,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO7B,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/SettableLimit.js

@@ -0,0 +1,30 @@
+import { ListenerSet } from "../ListenerSet.js";
+/**
+ * Limit to be used mostly for testing where the limit can be manually
+ * adjusted.
+ */
+export class SettableLimit {
+    _limit;
+    limitListeners = new ListenerSet();
+    constructor(limit) {
+        this._limit = limit;
+    }
+    get currentLimit() {
+        return this._limit;
+    }
+    addSample(_startTime, _rtt, _inflight, _didDrop) {
+        // No-op
+    }
+    setLimit(limit) {
+        if (limit !== this._limit) {
+            this._limit = limit;
+            this.limitListeners.notify(limit);
+        }
+    }
+    subscribe(consumer, options = {}) {
+        return this.limitListeners.subscribe(consumer, options);
+    }
+    toString() {
+        return `SettableLimit [limit=${this.currentLimit}]`;
+    }
+}

package/dist/limit/StreamingLimit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Contract for an algorithm that maintains a concurrency limit from a set of
+ * RTT samples.
+ */
+export interface AdaptiveLimit {
+    /** Current estimated concurrency limit. */
+    get currentLimit(): number;
+    /**
+     * Subscribe to limit changes. The callback runs whenever the limit updates.
+     *
+     * Returns a function to unsubscribe. Optional AbortSignal support is
+     * provided for ergonomic cancellation.
+     */
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    /**
+     * Adjust the estimated limit using a completed request sample.
+     * @param startTime Start time in fractional milliseconds (from performance.now())
+     * @param rtt Round trip time in fractional milliseconds
+     * @param inflight Number of inflight requests at the time the request started
+     * @param didDrop Whether the request was dropped (timeout or rejection)
+     */
+    addSample(startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+}
+//# sourceMappingURL=StreamingLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingLimit.d.ts","sourceRoot":"","sources":["../../src/limit/StreamingLimit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,IAAI,YAAY,IAAI,MAAM,CAAC;IAE3B;;;;;OAKG;IACH,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,MAAM,IAAI,CAAC;IAEd;;;;;;OAMG;IACH,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACrF"}

package/dist/limit/StreamingLimit.js

@@ -0,0 +1 @@
+export {};

package/dist/limit/TracingLimitDecorator.d.ts

@@ -0,0 +1,16 @@
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Limit decorator that logs each sample to the console at debug level
+ * before forwarding to the delegate.
+ */
+export declare class TracingLimitDecorator implements AdaptiveLimit {
+    private readonly delegate;
+    static wrap(delegate: AdaptiveLimit): TracingLimitDecorator;
+    constructor(delegate: AdaptiveLimit);
+    get currentLimit(): number;
+    addSample(startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+}
+//# sourceMappingURL=TracingLimitDecorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TracingLimitDecorator.d.ts","sourceRoot":"","sources":["../../src/limit/TracingLimitDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IAEzC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,qBAAqB;gBAI/C,QAAQ,EAAE,aAAa;IAInC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAKnF,SAAS,CACP,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,MAAM,IAAI;CAGd"}

package/dist/limit/TracingLimitDecorator.js

@@ -0,0 +1,23 @@
+/**
+ * Limit decorator that logs each sample to the console at debug level
+ * before forwarding to the delegate.
+ */
+export class TracingLimitDecorator {
+    delegate;
+    static wrap(delegate) {
+        return new TracingLimitDecorator(delegate);
+    }
+    constructor(delegate) {
+        this.delegate = delegate;
+    }
+    get currentLimit() {
+        return this.delegate.currentLimit;
+    }
+    addSample(startTime, rtt, inflight, didDrop) {
+        console.debug(`maxInFlight=${inflight} rtt=${rtt.toFixed(3)} ms`);
+        this.delegate.addSample(startTime, rtt, inflight, didDrop);
+    }
+    subscribe(consumer, options) {
+        return this.delegate.subscribe(consumer, options);
+    }
+}

package/dist/limit/VegasLimit.d.ts

@@ -0,0 +1,85 @@
+import type { MetricRegistry } from "../MetricRegistry.js";
+import type { AdaptiveLimit } from "./StreamingLimit.js";
+/**
+ * Limiter based on TCP Vegas where the limit increases by alpha if the
+ * queue_use is small (< alpha) and decreases by alpha if the queue_use is
+ * large (> beta).
+ *
+ * Queue size is calculated using the formula:
+ *   queue_use = limit - BWE * RTTnoLoad = limit * (1 - RTTnoLoad / RTTactual)
+ *
+ * For traditional TCP Vegas alpha is typically 2-3 and beta is typically 4-6.
+ * To allow for better growth and stability at higher limits we set
+ *   alpha = max(3, 10% of the current limit)
+ * and
+ *   beta = max(6, 20% of the current limit)
+ */
+export interface VegasLimitOptions {
+    initialLimit?: number;
+    maxConcurrency?: number;
+    smoothing?: number;
+    /**
+     * Optional strategy hooks that control threshold and growth/decay behavior.
+     */
+    policy?: {
+        /**
+         * Function to compute the alpha threshold as a function of the current
+         * estimated limit. Alpha is the lower threshold for the estimated queue
+         * size; below it the limit is increased aggressively.
+         */
+        alpha?(limit: number): number;
+        /**
+         * Function to compute the beta threshold as a function of the current
+         * estimated limit. Beta is the upper threshold; above it the limit is
+         * decreased.
+         */
+        beta?(limit: number): number;
+        /**
+         * Threshold below which the limit is increased by beta (aggressive).
+         */
+        threshold?(limit: number): number;
+        /**
+         * Compute the new limit when increasing.
+         */
+        increase?(limit: number): number;
+        /**
+         * Compute the new limit when decreasing.
+         */
+        decrease?(limit: number): number;
+    };
+    /**
+     * The limiter will probe for a new noload RTT every
+     * probeMultiplier * current_limit iterations. Default value is 30.
+     */
+    probeMultiplier?: number;
+    metricRegistry?: MetricRegistry;
+}
+export type VegasLimitPolicy = Required<NonNullable<VegasLimitOptions["policy"]>>;
+export declare class VegasLimit implements AdaptiveLimit {
+    private _limit;
+    private readonly limitListeners;
+    /** Estimated concurrency limit based on our algorithm */
+    private estimatedLimit;
+    private rttNoload;
+    /** Maximum allowed limit providing an upper bound failsafe */
+    private readonly maxLimit;
+    private readonly smoothing;
+    private readonly policy;
+    private readonly rttSampleListener;
+    private readonly probeMultiplier;
+    private probeCount;
+    private probeJitter;
+    constructor(options?: VegasLimitOptions);
+    private resetProbeJitter;
+    private shouldProbe;
+    addSample(startTime: number, rtt: number, inflight: number, didDrop: boolean): void;
+    get currentLimit(): number;
+    private applyNewLimit;
+    subscribe(consumer: (newLimit: number) => void, options?: {
+        signal?: AbortSignal;
+    }): () => void;
+    private computeNextLimit;
+    private updateEstimatedLimit;
+    toString(): string;
+}
+//# sourceMappingURL=VegasLimit.d.ts.map

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

@@ -0,0 +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"}