Exponential backoff if Sentry server returns 429

Author: benvinegar

src/raven.js

@@ -61,6 +61,8 @@ function Raven() {
     this._keypressTimeout;
     this._location = _window.location;
     this._lastHref = this._location && this._location.href;
+    this._backoffDuration = 0;
+    this._backoffStart = null;
 
     for (var method in this._originalConsole) {  // eslint-disable-line guard-for-in
       this._originalConsoleMethods[method] = this._originalConsole[method];
@@ -1320,8 +1322,15 @@ Raven.prototype = {
         return httpData;
     },
 
+    _shouldBackoff: function() {
+        return this._backoffDuration && now() - this._backoffStart < this._backoffDuration;
+    },
 
     _send: function(data) {
+        if (this._shouldBackoff()) {
+            return;
+        }
+
         var globalOptions = this._globalOptions;
 
         var baseData = {
@@ -1434,13 +1443,22 @@ Raven.prototype = {
             data: data,
             options: globalOptions,
             onSuccess: function success() {
+                self._backoffDuration = 0;
+                self._backoffStart = null;
+
                 self._triggerEvent('success', {
                     data: data,
                     src: url
                 });
                 callback && callback();
             },
             onError: function failure(error) {
+                // too many requests
+                if (!self._shouldBackoff() && error.request && error.request.status === 429) {
+                    self._backoffDuration = self._backoffDuration * 2 || 1000;
+                    self._backoffStart = now();
+                }
+
                 self._triggerEvent('failure', {
                     data: data,
                     src: url
@@ -1468,7 +1486,9 @@ Raven.prototype = {
                     opts.onSuccess();
                 }
             } else if (opts.onError) {
-                opts.onError(new Error('Sentry error code: ' + request.status));
+                var err = new Error('Sentry error code: ' + request.status);
+                err.request = request;
+                opts.onError(err);
             }
         }
 

test/raven.test.js

@@ -1137,6 +1137,77 @@ describe('globals', function() {
             assert.equal(data.message, shortMessage);
             assert.equal(data.exception.values[0].value, shortMessage);
         });
+
+        it('should bail out if time elapsed does not exceed backoffDuration', function () {
+            this.sinon.stub(Raven, 'isSetup').returns(true);
+            this.sinon.stub(Raven, '_makeRequest');
+
+            Raven._backoffDuration = 1000;
+            Raven._backoffStart = 100;
+            this.clock.tick(100); // tick 100 ms - NOT past backoff duration
+
+            Raven._send({message: 'bar'});
+            assert.isFalse(Raven._makeRequest.called);
+        });
+
+        it('should proceed if time elapsed exceeds backoffDuration', function () {
+            this.sinon.stub(Raven, 'isSetup').returns(true);
+            this.sinon.stub(Raven, '_makeRequest');
+
+            Raven._backoffDuration = 1000;
+            Raven._backoffStart = 100;
+            this.clock.tick(1000); // advance clock 1000 ms - past backoff duration
+
+            Raven._send({message: 'bar'});
+            assert.isTrue(Raven._makeRequest.called);
+        });
+
+        it('should set backoffDuration and backoffStart if onError is fired w/ 429 response', function () {
+            this.sinon.stub(Raven, 'isSetup').returns(true);
+            this.sinon.stub(Raven, '_makeRequest');
+
+            Raven._send({message: 'bar'});
+            var opts = Raven._makeRequest.lastCall.args[0];
+            var mockError = new Error('429: Too many requests');
+            mockError.request = {
+                status: 429
+            };
+            opts.onError(mockError);
+
+            assert.equal(Raven._backoffStart, 100); // clock is at 100ms
+            assert.equal(Raven._backoffDuration, 1000);
+
+            this.clock.tick(1); // only 1ms
+            opts.onError(mockError);
+
+            // since the backoff has started, a subsequent 429 within the backoff period
+            // should not not the start/duration
+            assert.equal(Raven._backoffStart, 100);
+            assert.equal(Raven._backoffDuration, 1000);
+
+            this.clock.tick(1000); // move past backoff period
+            opts.onError(mockError);
+
+            // another failure has occurred, this time *after* the backoff period - should increase
+            assert.equal(Raven._backoffStart, 1101);
+            assert.equal(Raven._backoffDuration, 2000);
+        });
+
+        it('should reset backoffDuration and backoffStart if onSuccess is fired (200)', function () {
+            this.sinon.stub(Raven, 'isSetup').returns(true);
+            this.sinon.stub(Raven, '_makeRequest');
+
+            Raven._backoffDuration = 1000;
+            Raven._backoffStart = 0;
+            this.clock.tick(1001); // tick clock just past time necessary
+
+            Raven._send({message: 'bar'});
+            var opts = Raven._makeRequest.lastCall.args[0];
+            opts.onSuccess({});
+
+            assert.equal(Raven._backoffStart, null); // clock is at 100ms
+            assert.equal(Raven._backoffDuration, 0);
+        });
     });
 
     describe('makeRequest', function() {
@@ -1188,6 +1259,24 @@ describe('globals', function() {
 
             window.XDomainRequest = oldXDR
         });
+
+        it('should pass a request object to onError', function (done) {
+            XMLHttpRequest.prototype.withCredentials = true;
+
+            Raven._makeRequest({
+                url: 'http://localhost/',
+                auth: {a: '1', b: '2'},
+                data: {foo: 'bar'},
+                options: Raven._globalOptions,
+                onError: function (error) {
+                    assert.equal(error.request.status, 429);
+                    done();
+                }
+            });
+
+            var lastXhr = this.requests[this.requests.length - 1];
+            lastXhr.respond(429, {'Content-Type': 'text/html'}, 'Too many requests');
+        });
     });
 
     describe('handleOnErrorStackInfo', function () {