Rate Limiter

There are currently two forms of rate limiter (both quite primitive).

1. Burst
2. Spread

Make sure to check out some simple benchmarks here.

Burst

Burst is the default rate limiter.

So for example, with a rate limit of 10r/10s, say you want to send 35 requests almost all at the same time:

1. Request #1 is accepted, and your rate limit starts.

2. Requests #2-10 are accepted in almost the same second.

3. You are now rate limited until 10 seconds from Request #1.

4. Rate limit is now lifted.

5. Same as above (#+10).

6. Same as above (#+10).

7. Rate limit now lifted, and the Requests #31-35 are processed in like 1 second and we're done.

Which should net us an execution time of around 30000ms + code execution in ms.

You can test out the rate limiter (and see that it supports simultaneous requests to multiple regions) with the following code:

var num = 45 // # of requests

function count(err, data) {
  if (data) --num
  if (err) console.error(err)
  if (num == 0) console.timeEnd('api')
}

console.time('api')
for (var i = 0; i < 15; ++i) {
  k.Champion.list('na', count)
  k.Champion.list('kr', count)
  k.Champion.list('euw', count)
}

This should output something like api: 11820.972ms.

var num = 300 // # of requests

function count(err, data) {
  if (data) --num
  if (err) console.error(err)
  if (num == 0) console.timeEnd('api')
}

console.time('api')
for (var i = 0; i < 100; ++i) {
  k.Champion.list('na', count)
  k.Champion.list('kr', count)
  k.Champion.list('euw', count)
}

This should output something like api: 100186.515ms.

To test that it works with retry headers, just run the program while sending a few requests from your browser to intentionally rate limit yourself.

Because of these lines, if (data) --num and if (num == 0) console.timeEnd('api'), you can tell if all your requests went through.

Spread

To initialize a spread rate limiter, initialize Kindred through the standard way, but add spread: true to the config object.

var KindredAPI = require('kindred-api')

var RIOT_API_KEY = 'whatever'
var REGIONS = KindredAPI.REGIONS
var LIMITS = KindredAPI.LIMITS
var CACHE_TYPES = KindredAPI.CACHE_TYPES

var k = new KindredAPI.Kindred({
  key: RIOT_API_KEY,
  defaultRegion: REGIONS.NORTH_AMERICA,
  debug: true,
  limits: LIMITS.DEV,
  spread: true, // this!
  cacheOptions: CACHE_TYPES[0]
})

Since spreading out requests naturally mean requests fill up the window more tightly, the execution time should be longer. Right now, I spread the requests by basically adding a rate limiter per 1~s (it's not actually 1s).

So if you are using a DEV key, you'll make 1 request at almost a rate of 1s. If you are using a PROD key, you'll make 50 requests at almost a rate of 1s.

var num = 45 // # of requests

function count(err, data) {
  if (data) --num
  if (err) console.error(err)
  if (num == 0) console.timeEnd('api')
}

console.time('api')
for (var i = 0; i < 15; ++i) {
  k.Champion.list('na', count)
  k.Champion.list('kr', count)
  k.Champion.list('euw', count)
}

This should output something like api: 15779.552ms, unlike in the Burst example where it is 11820.972ms. The final 5 requests were spread over the last extra 3-4 seconds.

Note, if you sent the maximum number of requests (20 instead of 15), you would be at around api: 20000ms naturally.

The next burst example should output something like api: 109209.904ms. There's an extra 9 seconds here, but I'm pretty sure this is because of code execution time and faulty math. Nonetheless, the requests are still spread out.