How to process requests evenly with RateLimiterQueue?

I’m sending requests to a heavily rate-limited service but want them all to get through eventually, so I have a RateLimiterQueue with the default maximum size, wrapping a RateLimiterMySQL which is using the Sequelize backend for MySQL.

The issue is that whilst we have configured the service to have 10 points per hour, only 5 requests are being executed per hour.

I have the limiter set with the following config (as well as database specific config):

{
  "duration": 3600,
  "points": 10,
  "execEvenly": true
}

And the queue wrapping the limiter has no additional configuration. Is this a known issue?

EDIT: use an example from Consume points evenly article. At the time of this edit, execEvenly option doesn’t work with RateLimiterQueue.

[sam-lord]

This is all working perfectly. The code is really simple now:

const {RateLimiterMySQL, RateLimiterMemory} = require('rate-limiter-flexible');
const RateLimiterAbstract = require('rate-limiter-flexible/lib/RateLimiterAbstract');

module.exports = class RateLimiterCustom extends RateLimiterAbstract {
    constructor(options = {}, callback) {
        super(options);

        const limiterType = (options.storeClient)
            ? RateLimiterMySQL
            : RateLimiterMemory;

        const mainLimiter = new limiterType(Object.assign({}, options, {
            keyPrefix: 'main'
        }), callback);

        const intervalLimiter = new limiterType(Object.assign({}, options, {
            keyPrefix: 'interval',
            points: 1,
            duration: Math.ceil(this.duration / this.points)
        }));

        this._mainLimiter = mainLimiter;
        this._intervalLimiter = intervalLimiter;
    }

    async consume(key, points = 1, options = {}) {
        await this._intervalLimiter.consume(key, points, options);
        return await this._mainLimiter.consume(key, points, options);
    }

    penalty(key, points = 1) {
        return this._mainLimiter.penalty(key, points);
    }

    reward(key, points = 1) {
        return this._mainLimiter.reward(key, points);
    }

    get(key) {
        return this._mainLimiter.get(key);
    }

    set(key, points, secDuration) {
        return this._mainLimiter.set(key, points, secDuration);
    }

    block(key, secDuration) {
        return this._mainLimiter.block(key, secDuration);
    }

    delete(key) {
        return this._mainLimiter.delete(key);
    }
};

Thanks once again for the help with this - hopefully this ends up being useful to others with this type of use-case

[animir]

@sam-lord You’re welcome. It looks nice.

There is a separate issue for execEvenly option bug: https://github.com/animir/node-rate-limiter-flexible/issues/113

And I created a knowledge base article with slightly changed example: Consume points evenly