@posthog/core 1.3.1 → 1.4.0

package/dist/utils/bucketed-rate-limiter.d.ts

@@ -1,23 +1,19 @@
 import { Logger } from '../types';
 export declare class BucketedRateLimiter<T extends string | number> {
-    private readonly _options;
     private _bucketSize;
     private _refillRate;
     private _refillInterval;
     private _onBucketRateLimited?;
     private _buckets;
-    private _removeInterval;
-    constructor(_options: {
+    constructor(options: {
         bucketSize: number;
         refillRate: number;
         refillInterval: number;
         _logger: Logger;
         _onBucketRateLimited?: (key: T) => void;
     });
-    private _refillBuckets;
-    private _getBucket;
-    private _setBucket;
-    consumeRateLimit: (key: T) => boolean;
+    private _applyRefill;
+    consumeRateLimit(key: T): boolean;
     stop(): void;
 }
 //# sourceMappingURL=bucketed-rate-limiter.d.ts.map

package/dist/utils/bucketed-rate-limiter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bucketed-rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/bucketed-rate-limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAGjC,qBAAa,mBAAmB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAUtD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAT3B,OAAO,CAAC,WAAW,CAAA;IACnB,OAAO,CAAC,WAAW,CAAA;IACnB,OAAO,CAAC,eAAe,CAAA;IACvB,OAAO,CAAC,oBAAoB,CAAC,CAAkB;IAE/C,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,eAAe,CAA4B;gBAGhC,QAAQ,EAAE;QACzB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,cAAc,EAAE,MAAM,CAAA;QACtB,OAAO,EAAE,MAAM,CAAA;QACf,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;KACxC;IAqBH,OAAO,CAAC,cAAc,CAUrB;IAED,OAAO,CAAC,UAAU,CAEjB;IACD,OAAO,CAAC,UAAU,CAEjB;IAEM,gBAAgB,GAAI,KAAK,CAAC,aAiBhC;IAEM,IAAI;CAMZ"}
+{"version":3,"file":"bucketed-rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/bucketed-rate-limiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAMjC,qBAAa,mBAAmB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACxD,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,oBAAoB,CAAC,CAAkB;IAC/C,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,OAAO,EAAE;QACnB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,cAAc,EAAE,MAAM,CAAA;QACtB,OAAO,EAAE,MAAM,CAAA;QACf,oBAAoB,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAA;KACxC;IAOD,OAAO,CAAC,YAAY;IAWb,gBAAgB,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IA0BjC,IAAI,IAAI,IAAI;CAGpB"}

package/dist/utils/bucketed-rate-limiter.js

@@ -27,43 +27,43 @@ __webpack_require__.d(__webpack_exports__, {
     BucketedRateLimiter: ()=>BucketedRateLimiter
 });
 const external_number_utils_js_namespaceObject = require("./number-utils.js");
+const ONE_DAY_IN_MS = 86400000;
 class BucketedRateLimiter {
-    constructor(_options){
-        this._options = _options;
+    constructor(options){
         this._buckets = {};
-        this._refillBuckets = ()=>{
-            Object.keys(this._buckets).forEach((key)=>{
-                const newTokens = this._getBucket(key) + this._refillRate;
-                if (newTokens >= this._bucketSize) delete this._buckets[key];
-                else this._setBucket(key, newTokens);
-            });
-        };
-        this._getBucket = (key)=>this._buckets[String(key)];
-        this._setBucket = (key, value)=>{
-            this._buckets[String(key)] = value;
-        };
-        this.consumeRateLimit = (key)=>{
-            let tokens = this._getBucket(key) ?? this._bucketSize;
-            tokens = Math.max(tokens - 1, 0);
-            if (0 === tokens) return true;
-            this._setBucket(key, tokens);
-            const hasReachedZero = 0 === tokens;
-            if (hasReachedZero) this._onBucketRateLimited?.(key);
-            return hasReachedZero;
-        };
-        this._onBucketRateLimited = this._options._onBucketRateLimited;
-        this._bucketSize = (0, external_number_utils_js_namespaceObject.clampToRange)(this._options.bucketSize, 0, 100, this._options._logger);
-        this._refillRate = (0, external_number_utils_js_namespaceObject.clampToRange)(this._options.refillRate, 0, this._bucketSize, this._options._logger);
-        this._refillInterval = (0, external_number_utils_js_namespaceObject.clampToRange)(this._options.refillInterval, 0, 86400000, this._options._logger);
-        this._removeInterval = setInterval(()=>{
-            this._refillBuckets();
-        }, this._refillInterval);
+        this._onBucketRateLimited = options._onBucketRateLimited;
+        this._bucketSize = (0, external_number_utils_js_namespaceObject.clampToRange)(options.bucketSize, 0, 100, options._logger);
+        this._refillRate = (0, external_number_utils_js_namespaceObject.clampToRange)(options.refillRate, 0, this._bucketSize, options._logger);
+        this._refillInterval = (0, external_number_utils_js_namespaceObject.clampToRange)(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
     }
-    stop() {
-        if (this._removeInterval) {
-            clearInterval(this._removeInterval);
-            this._removeInterval = void 0;
+    _applyRefill(bucket, now) {
+        const elapsedMs = now - bucket.lastAccess;
+        const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
+        if (refillIntervals > 0) {
+            const tokensToAdd = refillIntervals * this._refillRate;
+            bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
+            bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
+        }
+    }
+    consumeRateLimit(key) {
+        const now = Date.now();
+        const keyStr = String(key);
+        let bucket = this._buckets[keyStr];
+        if (bucket) this._applyRefill(bucket, now);
+        else {
+            bucket = {
+                tokens: this._bucketSize,
+                lastAccess: now
+            };
+            this._buckets[keyStr] = bucket;
         }
+        if (0 === bucket.tokens) return true;
+        bucket.tokens--;
+        if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
+        return 0 === bucket.tokens;
+    }
+    stop() {
+        this._buckets = {};
     }
 }
 exports.BucketedRateLimiter = __webpack_exports__.BucketedRateLimiter;

package/dist/utils/bucketed-rate-limiter.mjs

@@ -1,41 +1,41 @@
 import { clampToRange } from "./number-utils.mjs";
+const ONE_DAY_IN_MS = 86400000;
 class BucketedRateLimiter {
-    constructor(_options){
-        this._options = _options;
+    constructor(options){
         this._buckets = {};
-        this._refillBuckets = ()=>{
-            Object.keys(this._buckets).forEach((key)=>{
-                const newTokens = this._getBucket(key) + this._refillRate;
-                if (newTokens >= this._bucketSize) delete this._buckets[key];
-                else this._setBucket(key, newTokens);
-            });
-        };
-        this._getBucket = (key)=>this._buckets[String(key)];
-        this._setBucket = (key, value)=>{
-            this._buckets[String(key)] = value;
-        };
-        this.consumeRateLimit = (key)=>{
-            let tokens = this._getBucket(key) ?? this._bucketSize;
-            tokens = Math.max(tokens - 1, 0);
-            if (0 === tokens) return true;
-            this._setBucket(key, tokens);
-            const hasReachedZero = 0 === tokens;
-            if (hasReachedZero) this._onBucketRateLimited?.(key);
-            return hasReachedZero;
-        };
-        this._onBucketRateLimited = this._options._onBucketRateLimited;
-        this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger);
-        this._refillRate = clampToRange(this._options.refillRate, 0, this._bucketSize, this._options._logger);
-        this._refillInterval = clampToRange(this._options.refillInterval, 0, 86400000, this._options._logger);
-        this._removeInterval = setInterval(()=>{
-            this._refillBuckets();
-        }, this._refillInterval);
+        this._onBucketRateLimited = options._onBucketRateLimited;
+        this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger);
+        this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger);
+        this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
     }
-    stop() {
-        if (this._removeInterval) {
-            clearInterval(this._removeInterval);
-            this._removeInterval = void 0;
+    _applyRefill(bucket, now) {
+        const elapsedMs = now - bucket.lastAccess;
+        const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
+        if (refillIntervals > 0) {
+            const tokensToAdd = refillIntervals * this._refillRate;
+            bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
+            bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
+        }
+    }
+    consumeRateLimit(key) {
+        const now = Date.now();
+        const keyStr = String(key);
+        let bucket = this._buckets[keyStr];
+        if (bucket) this._applyRefill(bucket, now);
+        else {
+            bucket = {
+                tokens: this._bucketSize,
+                lastAccess: now
+            };
+            this._buckets[keyStr] = bucket;
         }
+        if (0 === bucket.tokens) return true;
+        bucket.tokens--;
+        if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
+        return 0 === bucket.tokens;
+    }
+    stop() {
+        this._buckets = {};
     }
 }
 export { BucketedRateLimiter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/core",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/utils/bucketed-rate-limiter.spec.ts

@@ -19,15 +19,272 @@ describe('BucketedRateLimiter', () => {
     jest.clearAllMocks()
   })
 
-  test('it is not rate limited by default', () => {
-    const result = rateLimiter.consumeRateLimit('ResizeObserver')
-    expect(result).toBe(false)
+  describe('basic consumption', () => {
+    test('it is not rate limited by default', () => {
+      const result = rateLimiter.consumeRateLimit('ResizeObserver')
+      expect(result).toBe(false)
+    })
+
+    test('returns bucket is rate limited if no mutations are left', () => {
+      rateLimiter['_buckets']['ResizeObserver'] = { tokens: 0, lastAccess: Date.now() }
+
+      const result = rateLimiter.consumeRateLimit('ResizeObserver')
+      expect(result).toBe(true)
+    })
+
+    test.each([
+      { bucketSize: 1, consumptions: 1 },
+      { bucketSize: 5, consumptions: 5 },
+      { bucketSize: 10, consumptions: 10 },
+      { bucketSize: 50, consumptions: 50 },
+    ])('exhausts bucket of size $bucketSize after $consumptions consumptions', ({ bucketSize, consumptions }) => {
+      const limiter = new BucketedRateLimiter({
+        bucketSize,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+      })
+
+      for (let i = 0; i < consumptions - 1; i++) {
+        expect(limiter.consumeRateLimit('test')).toBe(false)
+      }
+
+      expect(limiter.consumeRateLimit('test')).toBe(true)
+      // can check the same bucket more than once
+      expect(limiter.consumeRateLimit('test')).toBe(true)
+    })
+  })
+
+  describe('refill behavior', () => {
+    test('refills tokens based on elapsed time', () => {
+      const key = 'ResizeObserver'
+
+      for (let i = 0; i < 9; i++) {
+        expect(rateLimiter.consumeRateLimit(key)).toBe(false)
+      }
+
+      expect(rateLimiter.consumeRateLimit(key)).toBe(true)
+
+      jest.advanceTimersByTime(2000)
+
+      const result = rateLimiter.consumeRateLimit(key)
+      expect(result).toBe(false)
+
+      const bucket = rateLimiter['_buckets'][key]
+      expect(bucket.tokens).toBe(1)
+    })
+
+    test('refills to bucket size maximum', () => {
+      const key = 'ResizeObserver'
+      rateLimiter.consumeRateLimit(key)
+
+      jest.advanceTimersByTime(20000)
+
+      rateLimiter.consumeRateLimit(key)
+
+      const bucket = rateLimiter['_buckets'][key]
+      expect(bucket.tokens).toBe(9)
+    })
+
+    test('partial refill intervals do not refill tokens', () => {
+      const key = 'test'
+
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit(key)
+      }
+
+      jest.advanceTimersByTime(999)
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(0)
+    })
+
+    test.each([
+      { refillRate: 1, intervals: 1, expected: 9 },
+      { refillRate: 2, intervals: 1, expected: 9 },
+      { refillRate: 1, intervals: 2, expected: 9 },
+      { refillRate: 3, intervals: 1, tokensLeft: 5, expected: 7 },
+      { refillRate: 2, intervals: 2, tokensLeft: 5, expected: 8 },
+    ])(
+      'with rate $refillRate, $intervals intervals, starting at $tokensLeft tokens, ends at $expected',
+      ({ refillRate, intervals, tokensLeft = 9, expected }) => {
+        const limiter = new BucketedRateLimiter({
+          bucketSize: 10,
+          refillRate,
+          refillInterval: 1000,
+          _logger: {} as unknown as Logger,
+        })
+
+        const consumptions = 10 - tokensLeft
+        for (let i = 0; i < consumptions; i++) {
+          limiter.consumeRateLimit('test')
+        }
+
+        jest.advanceTimersByTime(intervals * 1000)
+
+        limiter.consumeRateLimit('test')
+        expect(limiter['_buckets']['test'].tokens).toBe(expected)
+      }
+    )
+  })
+
+  describe('bucket isolation', () => {
+    test('different keys maintain separate buckets', () => {
+      const key1 = 'bucket1'
+      const key2 = 'bucket2'
+
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit(key1)
+      }
+
+      expect(rateLimiter.consumeRateLimit(key1)).toBe(true)
+      expect(rateLimiter.consumeRateLimit(key2)).toBe(false)
+
+      expect(rateLimiter['_buckets'][key1].tokens).toBe(0)
+      expect(rateLimiter['_buckets'][key2].tokens).toBe(9)
+    })
+
+    test('supports both string and number keys', () => {
+      const limiter = new BucketedRateLimiter<string | number>({
+        bucketSize: 5,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+      })
+
+      for (let i = 0; i < 4; i++) {
+        limiter.consumeRateLimit('string-key')
+        limiter.consumeRateLimit(123)
+      }
+
+      expect(limiter['_buckets']['string-key'].tokens).toBe(1)
+      expect(limiter['_buckets']['123'].tokens).toBe(1)
+    })
+  })
+
+  describe('callback behavior', () => {
+    test('invokes callback when bucket reaches zero', () => {
+      const callback = jest.fn()
+      const limiter = new BucketedRateLimiter({
+        bucketSize: 3,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+        _onBucketRateLimited: callback,
+      })
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).not.toHaveBeenCalled()
+
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledWith('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+    })
+
+    test('does not invoke callback for subsequent calls when already at zero', () => {
+      const callback = jest.fn()
+      const limiter = new BucketedRateLimiter({
+        bucketSize: 2,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+        _onBucketRateLimited: callback,
+      })
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+    })
+
+    test('invokes callback again after refill and re-exhaustion', () => {
+      const callback = jest.fn()
+      const limiter = new BucketedRateLimiter({
+        bucketSize: 2,
+        refillRate: 1,
+        refillInterval: 1000,
+        _logger: {} as unknown as Logger,
+        _onBucketRateLimited: callback,
+      })
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(1)
+
+      jest.advanceTimersByTime(2000)
+
+      limiter.consumeRateLimit('test')
+      limiter.consumeRateLimit('test')
+      expect(callback).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('stop method', () => {
+    test('clears all buckets', () => {
+      rateLimiter.consumeRateLimit('key1')
+      rateLimiter.consumeRateLimit('key2')
+
+      expect(Object.keys(rateLimiter['_buckets']).length).toBe(2)
+
+      rateLimiter.stop()
+
+      expect(Object.keys(rateLimiter['_buckets']).length).toBe(0)
+    })
+
+    test('resets state after stop', () => {
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit('test')
+      }
+
+      rateLimiter.stop()
+
+      expect(rateLimiter.consumeRateLimit('test')).toBe(false)
+      expect(rateLimiter['_buckets']['test'].tokens).toBe(9)
+    })
   })
 
-  test('returns true if no mutations are left', () => {
-    rateLimiter['_buckets']['ResizeObserver'] = 0
+  describe('timestamp tracking', () => {
+    test('preserves fractional intervals', () => {
+      const key = 'test'
+      const startTime = Date.now()
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(9)
+
+      jest.advanceTimersByTime(500)
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(8)
 
-    const result = rateLimiter.consumeRateLimit('ResizeObserver')
-    expect(result).toBe(true)
+      jest.advanceTimersByTime(600)
+
+      rateLimiter.consumeRateLimit(key)
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime + 1000)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(8)
+    })
+
+    test('advances lastAccess by complete intervals on refill', () => {
+      const key = 'test'
+      const startTime = Date.now()
+
+      for (let i = 0; i < 9; i++) {
+        rateLimiter.consumeRateLimit(key)
+      }
+
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime)
+
+      jest.advanceTimersByTime(2500)
+
+      rateLimiter.consumeRateLimit(key)
+
+      expect(rateLimiter['_buckets'][key].lastAccess).toBe(startTime + 2000)
+      expect(rateLimiter['_buckets'][key].tokens).toBe(2)
+    })
   })
 })

package/src/utils/bucketed-rate-limiter.ts

@@ -1,85 +1,67 @@
 import { Logger } from '../types'
 import { clampToRange } from './number-utils'
 
+type Bucket = { tokens: number; lastAccess: number }
+const ONE_DAY_IN_MS = 86400000
+
 export class BucketedRateLimiter<T extends string | number> {
-  private _bucketSize
-  private _refillRate
-  private _refillInterval
+  private _bucketSize: number
+  private _refillRate: number
+  private _refillInterval: number
   private _onBucketRateLimited?: (key: T) => void
+  private _buckets: Record<string, Bucket> = {}
 
-  private _buckets: Record<string, number> = {}
-  private _removeInterval: NodeJS.Timeout | undefined
-
-  constructor(
-    private readonly _options: {
-      bucketSize: number
-      refillRate: number
-      refillInterval: number
-      _logger: Logger
-      _onBucketRateLimited?: (key: T) => void
-    }
-  ) {
-    this._onBucketRateLimited = this._options._onBucketRateLimited
-    this._bucketSize = clampToRange(this._options.bucketSize, 0, 100, this._options._logger)
-    this._refillRate = clampToRange(
-      this._options.refillRate,
-      0,
-      this._bucketSize, // never refill more than bucket size
-      this._options._logger
-    )
-    this._refillInterval = clampToRange(
-      this._options.refillInterval,
-      0,
-      86400000, // one day in milliseconds
-      this._options._logger
-    )
-    this._removeInterval = setInterval(() => {
-      this._refillBuckets()
-    }, this._refillInterval)
+  constructor(options: {
+    bucketSize: number
+    refillRate: number
+    refillInterval: number
+    _logger: Logger
+    _onBucketRateLimited?: (key: T) => void
+  }) {
+    this._onBucketRateLimited = options._onBucketRateLimited
+    this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger)
+    this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger)
+    this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger)
   }
 
-  private _refillBuckets = () => {
-    Object.keys(this._buckets).forEach((key) => {
-      const newTokens = this._getBucket(key) + this._refillRate
+  private _applyRefill(bucket: Bucket, now: number): void {
+    const elapsedMs = now - bucket.lastAccess
+    const refillIntervals = Math.floor(elapsedMs / this._refillInterval)
 
-      if (newTokens >= this._bucketSize) {
-        delete this._buckets[key]
-      } else {
-        this._setBucket(key, newTokens)
-      }
-    })
+    if (refillIntervals > 0) {
+      const tokensToAdd = refillIntervals * this._refillRate
+      bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize)
+      bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval
+    }
   }
 
-  private _getBucket = (key: T | string) => {
-    return this._buckets[String(key)]
-  }
-  private _setBucket = (key: T | string, value: number) => {
-    this._buckets[String(key)] = value
-  }
+  public consumeRateLimit(key: T): boolean {
+    const now = Date.now()
+    const keyStr = String(key)
 
-  public consumeRateLimit = (key: T) => {
-    let tokens = this._getBucket(key) ?? this._bucketSize
-    tokens = Math.max(tokens - 1, 0)
+    let bucket = this._buckets[keyStr]
 
-    if (tokens === 0) {
-      return true
+    if (!bucket) {
+      bucket = { tokens: this._bucketSize, lastAccess: now }
+      this._buckets[keyStr] = bucket
+    } else {
+      this._applyRefill(bucket, now)
     }
 
-    this._setBucket(key, tokens)
+    if (bucket.tokens === 0) {
+      return true
+    }
 
-    const hasReachedZero = tokens === 0
+    bucket.tokens--
 
-    if (hasReachedZero) {
+    if (bucket.tokens === 0) {
       this._onBucketRateLimited?.(key)
     }
 
-    return hasReachedZero
+    return bucket.tokens === 0
   }
 
-  public stop() {
-    if (this._removeInterval) {
-      clearInterval(this._removeInterval)
-      this._removeInterval = undefined
-    }
+  public stop(): void {
+    this._buckets = {}
   }
 }