feat(backoff): add option to specify options for custom backoff strategy

PATTERNS.md

@@ -166,6 +166,41 @@ myQueue.add({foo: 'bar'}, {
 });
 ```
 
+You may specify options for your strategy:
+```js
+var Queue = require('bull');
+
+var myQueue = new Queue("Server B", {
+  settings: {
+    backoffStrategies: {
+      // truncated binary exponential backoff
+      binaryExponential: function (attemptsMade, err, options) {
+        // Options can be undefined, you need to handle it by yourself
+        if (!options) {
+            options = {}
+        }
+        var delay = options.delay || 1000;
+        var truncate = options.truncate || 1000;
+        console.error({attemptsMade, err, options});
+        return Math.round(Math.random() * (Math.pow(2, Math.max(attemptsMade, truncate)) - 1) * delay)
+      }
+    }
+  }
+});
+
+myQueue.add({foo: 'bar'}, {
+  attempts: 10,
+  backoff: {
+    type: 'binaryExponential',
+    options: {
+        delay: 500,
+        truncate: 5
+    }
+  }
+});
+
+```
+
 You may base your backoff strategy on the error that the job throws:
 ```js
 const Queue = require('bull');

lib/backoffs.js

@@ -42,11 +42,15 @@ module.exports = {
     }
   },
 
-  calculate(backoff, attemptsMade, customStrategies, err) {
+  calculate(backoff, attemptsMade, customStrategies, err, strategyOptions) {
     if (backoff) {
-      const strategy = lookupStrategy(backoff, customStrategies);
+      const strategy = lookupStrategy(
+        backoff,
+        customStrategies,
+        strategyOptions
+      );
 
-      return strategy(attemptsMade, err);
+      return strategy(attemptsMade, err, strategyOptions);
     }
   }
 };

lib/job.js

@@ -274,6 +274,7 @@ Job.prototype.moveToFailed = async function(err, ignoreLock) {
   err = err || { message: 'Unknown reason' };
 
   this.failedReason = err.message;
+
   await this.queue.isReady();
 
   let command;
@@ -288,7 +289,8 @@ Job.prototype.moveToFailed = async function(err, ignoreLock) {
       this.opts.backoff,
       this.attemptsMade,
       this.queue.settings.backoffStrategies,
-      err
+      err,
+      _.get(this, 'opts.backoff.options', null)
     );
 
     if (delay === -1) {

test/test_queue.js

@@ -2273,6 +2273,48 @@ describe('Queue', () => {
       });
     });
 
+    it('should pass strategy options to custom backoff', function(done) {
+      this.timeout(12000);
+      queue = utils.buildQueue('test retries and backoffs', {
+        settings: {
+          backoffStrategies: {
+            custom(attemptsMade, err, strategyOptions) {
+              expect(strategyOptions.id).to.be.equal('FOO42');
+              return attemptsMade * 1000;
+            }
+          }
+        }
+      });
+      let start;
+      queue.isReady().then(() => {
+        queue.process((job, jobDone) => {
+          if (job.attemptsMade < 2) {
+            throw new Error('Not yet!');
+          }
+          jobDone();
+        });
+
+        start = Date.now();
+        queue.add(
+          { foo: 'bar' },
+          {
+            attempts: 3,
+            backoff: {
+              type: 'custom',
+              options: {
+                id: 'FOO42'
+              }
+            }
+          }
+        );
+      });
+      queue.on('completed', () => {
+        const elapse = Date.now() - start;
+        expect(elapse).to.be.greaterThan(3000);
+        done();
+      });
+    });
+
     it('should not retry a job if the custom backoff returns -1', done => {
       queue = utils.buildQueue('test retries and backoffs', {
         settings: {