@withjoy/limiter 0.1.3 → 0.1.5

package/README.md

@@ -23,6 +23,12 @@ Your client can use any subset of these Buckets, but when it does, the Best Prac
 
 However, for flexibility reasons, this is not strictly enforced.
 
+## Why limitd-redis ?
+Although this package is available on npm, it's no longer actively maintained. We've observed bugs in the existing published version, but these issues have already been resolved in the [limitd-redis](https://github.com/auth0/limitd-redis) gitHub repository. To address this, we've imported the latest stable version(v7.8.1) from there github repository and using it locally in the limiter.
+
+In case we need to update in the future, we can replace the "limitd-redis" directory with the latest version of [limitd-redis](https://github.com/auth0/limitd-redis) from their GitHub repository.
+
+Note: We need to add dependency from limitd-redis to limiter package json before publish. We are using limitd-redis as directly not package inside limiter. 
 
 ## Testing:
 

package/limitd-redis/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Auth0, Inc. <support@auth0.com> (http://auth0.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/limitd-redis/README.md

@@ -0,0 +1,183 @@
+[![Build Status](https://travis-ci.org/auth0/limitd-redis.svg?branch=master)](https://travis-ci.org/auth0/limitd-redis)
+
+`limitd-redis` is client for limits on top of `redis` using [Token Buckets](https://en.wikipedia.org/wiki/Token_bucket).
+It's a fork from [LimitDB](https://github.com/limitd/limitdb).
+
+## Installation
+
+```
+npm i limitd-redis
+```
+
+## Configure
+
+Create an instance of `limitd-redis` as follows:
+
+```js
+const Limitd = require('limitd-redis');
+
+const limitd = new Limitd({
+  uri: 'localhost',
+  //or
+  nodes: [{
+    port: 7000,
+    host: 'localhost'
+  }],
+  buckets: {
+    ip: {
+      size: 10,
+      per_second: 5
+    }
+  },
+  prefix: 'test:',
+  ping: {
+    interval: 1000,
+    maxFailedAttempts: 5,
+    reconnectIfFailed: true
+  }
+});
+```
+
+Options available:
+
+- `uri` (string): Redis Connection String.
+- `nodes` (array): [Redis Cluster Configuration](https://github.com/luin/ioredis#cluster).
+- `buckets` (object): Setup your bucket types.
+- `prefix` (string): Prefix keys in Redis.
+- `ping` (object): Configure ping to Redis DB.
+
+Buckets:
+
+- `size` (number): is the maximum content of the bucket. This is the maximum burst you allow.
+- `per_interval` (number): is the amount of tokens that the bucket receive on every interval.
+- `interval` (number): defines the interval in milliseconds.
+- `unlimited` (boolean = false): unlimited requests (skip take).
+- `skip_n_calls` (number): take will go to redis every `n` calls instead of going in every take. 
+
+Ping:
+
+- `interval` (number): represents the time between two consecutive pings. Default: 3000.
+- `maxFailedAttempts` (number): is the allowed number of failed pings before declaring the connection as dead. Default: 5.
+- `reconnectIfFailed` (boolean): indicates whether we should try to reconnect is the connection is declared dead. Default: true.
+
+You can also define your rates using `per_second`, `per_minute`, `per_hour`, `per_day`. So `per_second: 1` is equivalent to `per_interval: 1, interval: 1000`.
+
+If you omit `size`, limitdb assumes that `size` is the value of `per_interval`. So `size: 10, per_second: 10` is the same than `per_second: 10`.
+
+If you don't specify a filling rate with `per_interval` or any other `per_x`, the bucket is fixed and you have to manually reset it using `PUT`.
+
+You can also define `overrides` inside your type definitions as follows:
+
+```js
+buckets = {
+  ip: {
+    size: 10,
+    per_second: 5,
+    overrides: {
+      '127.0.0.1': {
+        size: 100,
+        per_second: 50
+      }
+    }
+  }
+}
+```
+
+In this case the specific bucket for `127.0.0.1` of type `ip` will have a greater limit.
+
+It is also possible to define overrides by regex:
+
+```js
+overrides: {
+  'local-ips': {
+    match:      /192\.168\./
+    size:       100,
+    per_second: 50
+  }
+}
+```
+
+It's possible to configure expiration of overrides:
+
+```js
+overrides: {
+  '54.32.12.31': {
+    size:       100,
+    per_second: 50,
+    until:      new Date(2016, 4, 1)
+  }
+}
+```
+
+## Breaking changes from `Limitdb`
+
+* Elements will have a default TTL of a week unless specified otherwise.
+
+## TAKE
+
+```js
+limitd.take(type, key, [count], (err, result) => {
+  console.log(result);
+});
+```
+
+`limitd.take` takes the following arguments:
+
+-  `type`: the bucket type.
+-  `key`: the identifier of the bucket.
+-  `count`: the amount of tokens you need. This is optional and the default is 1.
+-  `configOverride`: caller-provided bucket configuration for this operation
+
+The result object has:
+
+-  `conformant` (boolean): true if the requested amount is conformant to the limit.
+-  `remaining` (int): the amount of remaining tokens in the bucket.
+-  `reset` (int / unix timestamp): unix timestamp of the date when the bucket will be full again.
+-  `limit` (int): the size of the bucket.
+
+## PUT
+
+You can manually reset a fill a bucket using PUT:
+
+```js
+limitd.put(type, key, [count], (err, result) => {
+  console.log(result);
+});
+```
+
+`limitd.put` takes the following arguments:
+
+-  `type`: the bucket type.
+-  `key`: the identifier of the bucket.
+-  `count`: the amount of tokens you want to put in the bucket. This is optional and the default is the size of the bucket.
+-  `configOverride`: caller-provided bucket configuration for this operation
+
+## Overriding Configuration at Runtime
+Since the method of storing overrides for buckets in memory does not scale to a large number, limitd-redis provides a way for callers to pass in configuration from an external data store.  The shape of this `configOverride` parameter (available on `take`, `put`, `get`, and `wait`) is exactly the same as `Buckets` above ^.
+
+An example configuration override call might look like this:
+
+```js
+const configOverride = {
+  size: 45,
+  per_hour: 15
+}
+// take one
+limitd.take(type, key, { configOverride }, (err, result) => {
+  console.log(result);
+}
+// take multiple
+limitd.take(type, key, { count: 3, configOverride }, (err, result) => {
+  console.log(result);
+}););
+```
+
+Config overrides follow the same rules as Bucket configuration elements with respect to default size when not provided and ttl.
+
+## Author
+
+[Auth0](auth0.com)
+
+## License
+
+This project is licensed under the MIT license. See the [LICENSE](LICENSE) file for more info.

package/limitd-redis/docker-compose.yml

@@ -0,0 +1,11 @@
+services:
+  redis:
+    image: 'redis:6'
+    command: --save "" --appendonly no
+    ports:
+      - "6379:6379"
+  toxiproxy:
+    image: 'shopify/toxiproxy'
+    ports:
+      - "8474:8474"
+      - "22222:22222"

package/limitd-redis/index.js

@@ -0,0 +1,2 @@
+module.exports = require('./lib/client');
+module.exports.LimitDBRedis = require('./lib/db');

package/limitd-redis/lib/cb.js

@@ -0,0 +1,45 @@
+// Based on the work of Jeremy Martin: https://github.com/jmar777/cb
+// Added a second timeout(1) to force spinning again the event loop lap and verify if the initial operation has been successful
+module.exports = function(callback) {
+
+  var cb = function() {
+      if (timedout || (once && count)) return;
+      count += 1;
+      tid && clearTimeout(tid);
+
+      var args = Array.prototype.slice.call(arguments);
+      process.nextTick(function() {
+        if (!errback) return callback.apply(this, args);
+        args[0] ? errback(args[0]) : callback.apply(this, args.slice(1));
+      });
+
+    }, count = 0, once = false, timedout = false, errback, tid;
+
+  cb.timeout = function(ms) {
+    tid && clearTimeout(tid);
+    tid = setTimeout(function() {
+      // force another second timeout to verify if the operation has been successful
+      // No need to clear timeout since it has been triggered
+      tid = setTimeout(function() {
+        cb(new TimeoutError(ms));
+        timedout = true;
+      }, 1);
+    }, ms - 1);
+    return cb;
+  };
+
+  cb.error = function(func) { errback = func; return cb; };
+
+  cb.once = function() { once = true; return cb; };
+
+  return cb;
+
+};
+
+var TimeoutError = module.exports.TimeoutError = function TimeoutError(ms) {
+  this.message = 'Specified timeout of ' + ms + 'ms was reached';
+  Error.captureStackTrace(this, this.constructor);
+};
+TimeoutError.prototype = new Error;
+TimeoutError.prototype.constructor = TimeoutError;
+TimeoutError.prototype.name = 'TimeoutError';

package/limitd-redis/lib/client.js

@@ -0,0 +1,135 @@
+const _ = require('lodash');
+const retry = require('retry');
+const cbControl = require('./cb');
+const LimitDBRedis = require('./db');
+const disyuntor = require('disyuntor');
+const validation = require('./validation');
+const EventEmitter = require('events').EventEmitter;
+
+const ValidationError = validation.LimitdRedisValidationError;
+
+const circuitBreakerDefaults = {
+  timeout: '0.50s',
+  maxFailures: 50,
+  cooldown: '1s',
+  maxCooldown: '3s',
+  name: 'limitr',
+  trigger: (err) => {
+    return !(err instanceof ValidationError);
+  }
+};
+
+const retryDefaults = {
+  retries: 3,
+  minTimeout: 10,
+  maxTimeout: 30
+};
+
+class LimitdRedis extends EventEmitter {
+  constructor(params) {
+    super();
+
+    this.db = new LimitDBRedis(_.pick(params, [
+      'uri', 'nodes', 'buckets', 'prefix', 'slotsRefreshTimeout', 'slotsRefreshInterval',
+      'password', 'tls', 'dnsLookup', 'globalTTL', 'cacheSize', 'ping']));
+
+    this.db.on('error', (err) => {
+      this.emit('error', err);
+    });
+
+    this.db.on('ready', () => {
+      this.emit('ready');
+    });
+
+    this.db.on('node error', (err, node) => {
+      this.emit('node error', err, node);
+    });
+
+    this.breakerOpts = _.merge(circuitBreakerDefaults, params.circuitbreaker);
+    this.retryOpts = _.merge(retryDefaults, params.retry);
+    this.commandTimeout = params.commandTimeout || 75;
+
+    this.dispatch = disyuntor.wrapCallbackApi(this.breakerOpts, this.dispatch.bind(this));
+  }
+
+  static buildParams(type, key, opts, cb) {
+    const params = { type, key };
+    const optsType = typeof opts;
+
+    // handle lack of opts and/or cb
+    if (cb == null) {
+      if (optsType === 'function') {
+        cb = opts;
+        opts = undefined;
+      } else {
+        cb = _.noop;
+      }
+    }
+
+    if (optsType === 'number' || opts === 'all') {
+      params.count = opts;
+    }
+
+    if (optsType === 'object') {
+      _.assign(params, opts);
+    }
+
+    return [params, cb];
+  }
+
+  handler(method, type, key, opts, cb) {
+    let [params, callback] = LimitdRedis.buildParams(type, key, opts, cb);
+    this.dispatch(method, params, callback);
+  }
+
+  dispatch(method, params, cb) {
+    const operation = retry.operation(this.retryOpts);
+    operation.attempt((attempts) => {
+      this.db[method](params, cbControl((err, results) => {
+        if (err instanceof ValidationError) {
+          return cb(err, null, { attempts });
+        }
+
+        if (operation.retry(err)) {
+          return;
+        }
+
+        return cb(err ? operation.mainError() : null, results, { attempts });
+      }).timeout(this.commandTimeout));
+    });
+  }
+
+  take(type, key, opts, cb) {
+    this.handler('take', type, key, opts, cb);
+  }
+
+  wait(type, key, opts, cb) {
+    this.handler('wait', type, key, opts, cb);
+  }
+
+  get(type, key, opts, cb) {
+    this.handler('get', type, key, opts, cb);
+  }
+
+  put(type, key, opts, cb) {
+    this.handler('put', type, key, opts, cb);
+  }
+
+  reset(type, key, opts, cb) {
+    this.put(type, key, opts, cb);
+  }
+
+  resetAll(cb) {
+    this.db.resetAll(cb);
+  }
+
+  close(callback) {
+    this.db.close((err) => {
+      this.db.removeAllListeners();
+      callback(err);
+    });
+  }
+}
+
+module.exports = LimitdRedis;
+module.exports.ValidationError = ValidationError;