feat: global limiter caching (#22)

Author: SGrondin

lib/index.js

@@ -9,43 +9,53 @@ const routeMatcher = require('./route-matcher')(triggersNotificationPaths)
 const triggersNotification = throttlingPlugin.triggersNotification =
   routeMatcher.test.bind(routeMatcher)
 
+const groups = {}
+
+const createGroups = function (Bottleneck, common) {
+  groups.global = new Bottleneck.Group({
+    id: 'octokit-global',
+    maxConcurrent: 1,
+    ...common
+  })
+  groups.write = new Bottleneck.Group({
+    id: 'octokit-write',
+    maxConcurrent: 1,
+    minTime: 1000,
+    ...common
+  })
+  groups.notifications = new Bottleneck.Group({
+    id: 'octokit-notifications',
+    maxConcurrent: 1,
+    minTime: 3000,
+    ...common
+  })
+}
+
 function throttlingPlugin (octokit, octokitOptions = {}) {
   const {
     enabled = true,
     Bottleneck = BottleneckLight,
     id = 'no-id',
+    timeout = 1000 * 60 * 2, // Redis TTL: 2 minutes
     connection
   } = octokitOptions.throttle || {}
   if (!enabled) {
     return
   }
-  const common = {
-    connection,
-    timeout: 1000 * 60 * 10 // Redis TTL: 10 minutes
+  const common = { connection, timeout }
+
+  if (groups.global == null) {
+    createGroups(Bottleneck, common)
   }
+
   const state = Object.assign({
     clustering: connection != null,
     triggersNotification,
     minimumAbuseRetryAfter: 5,
     retryAfterBaseValue: 1000,
-    globalLimiter: new Bottleneck({
-      id: `octokit-global-${id}`,
-      maxConcurrent: 1,
-      ...common
-    }),
-    writeLimiter: new Bottleneck({
-      id: `octokit-write-${id}`,
-      maxConcurrent: 1,
-      minTime: 1000,
-      ...common
-    }),
-    triggersNotificationLimiter: new Bottleneck({
-      id: `octokit-notifications-${id}`,
-      maxConcurrent: 1,
-      minTime: 3000,
-      ...common
-    }),
-    retryLimiter: new Bottleneck()
+    retryLimiter: new Bottleneck(),
+    id,
+    ...groups
   }, octokitOptions.throttle)
 
   if (typeof state.onAbuseLimit !== 'function' || typeof state.onRateLimit !== 'function') {

lib/wrap-request.js

@@ -18,13 +18,13 @@ async function doRequest (state, request, options) {
 
   // Guarantee at least 1000ms between writes
   if (isWrite) {
-    await state.writeLimiter.schedule(jobOptions, noop)
+    await state.write.key(state.id).schedule(jobOptions, noop)
   }
 
   // Guarantee at least 3000ms between requests that trigger notifications
   if (isWrite && state.triggersNotification(options.url)) {
-    await state.triggersNotificationLimiter.schedule(jobOptions, noop)
+    await state.notifications.key(state.id).schedule(jobOptions, noop)
   }
 
-  return state.globalLimiter.schedule(jobOptions, request, options)
+  return state.global.key(state.id).schedule(jobOptions, request, options)
 }

test/integration/index.js

@@ -83,7 +83,7 @@ describe('Github API best practices', function () {
   it('Should maintain 1000ms between mutating requests', async function () {
     const octokit = new Octokit({
       throttle: {
-        writeLimiter: new Bottleneck({ minTime: 50 }),
+        write: new Bottleneck.Group({ minTime: 50 }),
         onAbuseLimit: () => 1,
         onRateLimit: () => 1
       }
@@ -120,8 +120,8 @@ describe('Github API best practices', function () {
   it('Should maintain 3000ms between requests that trigger notifications', async function () {
     const octokit = new Octokit({
       throttle: {
-        writeLimiter: new Bottleneck({ minTime: 50 }),
-        triggersNotificationLimiter: new Bottleneck({ minTime: 100 }),
+        write: new Bottleneck.Group({ minTime: 50 }),
+        notifications: new Bottleneck.Group({ minTime: 100 }),
         onAbuseLimit: () => 1,
         onRateLimit: () => 1
       }
@@ -175,8 +175,8 @@ describe('Github API best practices', function () {
   it('Should optimize throughput rather than maintain ordering', async function () {
     const octokit = new Octokit({
       throttle: {
-        writeLimiter: new Bottleneck({ minTime: 50 }),
-        triggersNotificationLimiter: new Bottleneck({ minTime: 100 }),
+        write: new Bottleneck.Group({ minTime: 50 }),
+        notifications: new Bottleneck.Group({ minTime: 100 }),
         onAbuseLimit: () => 1,
         onRateLimit: () => 1
       }