rollbar 2.25.1 → 2.26.0

package/test/apiUtility.test.js

@@ -105,6 +105,60 @@ describe('getTransportFromOptions', function() {
     expect(t.proxy).to.eql(options.proxy);
     expect(t.timeout).to.eql(undefined);
   });
+  describe('getTransportFromOptions', function() {
+    var defaults = {
+      hostname: 'api.com',
+      protocol: 'https:',
+      path: '/api/1',
+      search: '?abc=456',
+    };
+    var url = {
+      parse: function(_) {
+        return {
+          hostname: 'whatever.com',
+          protocol: 'http:',
+          pathname: '/api/42'
+        };
+      }
+    };
+    it('should use xhr by default', function(done) {
+      var options = {};
+      var t = u.getTransportFromOptions(options, defaults, url);
+      expect(t.transport).to.eql('xhr');
+      done();
+    });
+    it('should use fetch when requested', function(done) {
+      var options = {defaultTransport: 'fetch'};
+      var t = u.getTransportFromOptions(options, defaults, url);
+      expect(t.transport).to.eql('fetch');
+      done();
+    });
+    it('should use xhr when requested', function(done) {
+      var options = {defaultTransport: 'xhr'};
+      var t = u.getTransportFromOptions(options, defaults, url);
+      expect(t.transport).to.eql('xhr');
+      done();
+    });
+    it('should use xhr when fetch is unavailable', function(done) {
+      var options = {defaultTransport: 'fetch'};
+      var oldFetch = window.fetch;
+      self.fetch = undefined;
+      var t = u.getTransportFromOptions(options, defaults, url);
+      expect(t.transport).to.eql('xhr');
+      self.fetch = oldFetch;
+      done();
+    });
+    it('should use fetch when xhr is unavailable', function(done) {
+      var options = {defaultTransport: 'xhr'};
+      var oldXhr = window.XMLHttpRequest;
+      self.XMLHttpRequest = undefined;
+      var t = u.getTransportFromOptions(options, defaults, url);
+      expect(t.transport).to.eql('fetch');
+      self.XMLHttpRequest = oldXhr;
+      done();
+    });
+  });
+
 });
 
 describe('transportOptions', function() {

package/test/browser.rollbar.test.js

@@ -1495,17 +1495,21 @@ describe('options.autoInstrument', function() {
       if(xhr.readyState === 4) {
         try {
           setTimeout(function() {
-            server.respond();
+            try {
+              server.respond();
 
-            expect(server.requests.length).to.eql(2);
-            var body = JSON.parse(server.requests[1].requestBody);
+              expect(server.requests.length).to.eql(2);
+              var body = JSON.parse(server.requests[1].requestBody);
 
-            expect(body.data.body.trace.exception.message).to.eql('HTTP request failed with Status 404');
+              expect(body.data.body.trace.exception.message).to.eql('HTTP request failed with Status 404');
 
-            // Just knowing a stack is present is enough for this test.
-            expect(body.data.body.trace.frames.length).to.be.above(1);
+              // Just knowing a stack is present is enough for this test.
+              expect(body.data.body.trace.frames.length).to.be.above(1);
 
-            done();
+              done();
+            } catch (e) {
+              done(e);
+            }
           }, 1);
         } catch (e) {
           done(e);
@@ -1525,15 +1529,9 @@ describe('options.autoInstrument', function() {
 
     window.fetchStub = sinon.stub(window, 'fetch');
 
-    var readableStream = new ReadableStream({
-      start(controller) {
-        controller.enqueue(JSON.stringify({name: 'foo', password: '123456'}));
-        controller.close();
-      }
-    });
-
+    var responseBody = JSON.stringify({name: 'foo', password: '123456'});
     window.fetch.returns(Promise.resolve(new Response(
-      readableStream,
+      responseBody,
       { status: 200, statusText: 'OK', headers: { 'content-type': 'application/json', 'password': '123456' }}
     )));
 
@@ -1557,11 +1555,18 @@ describe('options.autoInstrument', function() {
     const fetchInit = {
       method: 'POST',
       headers: fetchHeaders,
-      body: JSON.stringify({name: 'bar', secret: 'xhr post'})
+      body: JSON.stringify({name: 'bar', secret: 'fetch post'})
     };
-    var fetchRequest = new Request('https://example.com/xhr-test');
+    var fetchRequest = new Request('https://example.com/fetch-test');
     window.fetch(fetchRequest, fetchInit)
     .then(function(response) {
+      // Assert that the original stream reader hasn't been read.
+      expect(response.bodyUsed).to.eql(false);
+      return response.text()
+    })
+    .then(function(text) {
+      expect(text).to.eql(responseBody);
+
       try {
         rollbar.log('test'); // generate a payload to inspect
       } catch (e) {
@@ -1573,8 +1578,9 @@ describe('options.autoInstrument', function() {
         try {
           server.respond();
 
-          expect(server.requests.length).to.eql(2);
-          var body = JSON.parse(server.requests[1].requestBody);
+          expect(window.fetchStub.called).to.be.ok();
+          expect(server.requests.length).to.eql(1);
+          var body = JSON.parse(server.requests[0].requestBody);
 
           // Verify request capture and scrubbing
           expect(body.data.body.telemetry[0].body.request).to.eql('{"name":"bar","secret":"********"}');
@@ -1582,19 +1588,12 @@ describe('options.autoInstrument', function() {
           // Verify request headers capture and case-insensitive scrubbing
           expect(body.data.body.telemetry[0].body.request_headers).to.eql({'content-type': 'application/json', secret: '********'});
 
-          // When using the Sinon test stub, the response body is populated in Headless Chrome 73,
-          // but not in 77. When using the Fetch API normally, it is populated in all tested Chrome versions.
-          // Disable here due to the Sinon limitation.
-          //
           // Verify response capture and scrubbing
-          // expect(body.data.body.telemetry[0].body.response.body).to.eql('{"name":"foo","password":"********"}');
+          expect(body.data.body.telemetry[0].body.response.body).to.eql('{"name":"foo","password":"********"}');
 
           // Verify response headers capture and case-insensitive scrubbing
           expect(body.data.body.telemetry[0].body.response.headers).to.eql({'content-type': 'application/json', password: '********'});
 
-          // Assert that the original stream reader hasn't been read.
-          expect(response.bodyUsed).to.eql(false);
-
           rollbar.configure({ autoInstrument: false });
           window.fetch.restore();
           done();
@@ -1606,7 +1605,7 @@ describe('options.autoInstrument', function() {
     })
   });
 
-  it('should add telemetry events for fetch calls', function(done) {
+  it('should report error for http 4xx fetch calls, when enabled', function(done) {
     var server = window.server;
     stubResponse(server);
     server.requests.length = 0;
@@ -1659,6 +1658,80 @@ describe('options.autoInstrument', function() {
     })
   });
 
+  it('should add telemetry headers when fetch Headers object is undefined', function(done) {
+    var server = window.server;
+    stubResponse(server);
+    server.requests.length = 0;
+
+    window.fetchStub = sinon.stub(window, 'fetch');
+
+    var readableStream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(JSON.stringify({name: 'foo', password: '123456'}));
+        controller.close();
+      }
+    });
+
+    window.fetch.returns(Promise.resolve(new Response(
+      readableStream,
+      { status: 200, statusText: 'OK', headers: { 'content-type': 'application/json', 'password': '123456' }}
+    )));
+
+    var options = {
+      accessToken: 'POST_CLIENT_ITEM_TOKEN',
+      autoInstrument: {
+        log: false,
+        network: true,
+        networkResponseHeaders: true,
+        networkRequestHeaders: true
+      }
+    };
+    var rollbar = window.rollbar = new Rollbar(options);
+
+    // Remove Headers from window object
+    var originalHeaders = window.Headers;
+    delete window.Headers;
+
+    const fetchInit = {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json', Secret: '123456'},
+      body: JSON.stringify({name: 'bar', secret: 'xhr post'})
+    };
+    var fetchRequest = new Request('https://example.com/xhr-test');
+    window.fetch(fetchRequest, fetchInit)
+    .then(function(response) {
+      try {
+        rollbar.log('test'); // generate a payload to inspect
+        setTimeout(function() {
+          try {
+            server.respond();
+
+            expect(server.requests.length).to.eql(1);
+            var body = JSON.parse(server.requests[0].requestBody);
+
+            // Verify request headers capture and case-insensitive scrubbing
+            expect(body.data.body.telemetry[0].body.request_headers).to.eql({'content-type': 'application/json', secret: '********'});
+
+            // Verify response headers capture and case-insensitive scrubbing
+            expect(body.data.body.telemetry[0].body.response.headers).to.eql({'content-type': 'application/json', password: '********'});
+
+            // Assert that the original stream reader hasn't been read.
+            expect(response.bodyUsed).to.eql(false);
+
+            rollbar.configure({ autoInstrument: false });
+            window.fetch.restore();
+            window.Headers = originalHeaders;
+            done();
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    })
+  });
+
   it('should add a diagnostic message when wrapConsole fails', function(done) {
     var server = window.server;
     stubResponse(server);

package/test/browser.transforms.test.js

@@ -226,9 +226,10 @@ describe('addRequestInfo', function() {
   it('should use window info to set request properties', function(done) {
     var args = ['a message'];
     var item = itemFromArgs(args);
-    var options = {};
+    var options = { captureIp: 'anonymize' };
     t.addRequestInfo(window)(item, options, function(e, i) {
       expect(i.data.request).to.be.ok();
+      expect(i.data.request.user_ip).to.eql('$remote_ip_anonymize');
       done(e);
     });
   });
@@ -243,6 +244,19 @@ describe('addRequestInfo', function() {
       done(e);
     });
   });
+  it('should honor captureIp without window', function(done) {
+    var args = ['a message'];
+    var item = itemFromArgs(args);
+    item.data = {};
+    var options = { captureIp: true };
+    var w = null;
+    t.addRequestInfo(w)(item, options, function(e, i) {
+      expect(i.data.request.url).to.not.be.ok();
+      expect(i.data.request.query_string).to.not.be.ok();
+      expect(i.data.request.user_ip).to.eql('$remote_ip');
+      done(e);
+    });
+  });
 });
 
 describe('addClientInfo', function() {

package/test/browser.transport.test.js

@@ -86,6 +86,65 @@ describe('post', function() {
     };
     t.post(accessToken, options, payload, callback, requestFactory.getInstance);
   });
+  describe('post', function() {
+    beforeEach(function (done) {
+      window.fetchStub = sinon.stub(window, 'fetch');
+      window.server = sinon.createFakeServer();
+      done();
+    });
+
+    afterEach(function () {
+      window.fetch.restore();
+      window.server.restore();
+    });
+
+    function stubFetchResponse() {
+      window.fetch.returns(Promise.resolve(new Response(
+        JSON.stringify({ err: 0, message: 'OK', result: { uuid: uuid }}),
+        { status: 200, statusText: 'OK', headers: { 'Content-Type': 'application/json' }}
+      )));
+    }
+
+    function stubXhrResponse() {
+      window.server.respondWith(
+        [
+          200,
+          { 'Content-Type': 'application/json' },
+          '{"err": 0, "result":{ "uuid": "d4c7acef55bf4c9ea95e4fe9428a8287"}}'
+        ]
+      );
+    }
+
+    var uuid = 'd4c7acef55bf4c9ea95e4fe9428a8287';
+
+    it('should use fetch when requested', function(done) {
+      var callback = function(err, resp) {
+        expect(window.fetchStub.called).to.be.ok();
+        expect(server.requests.length).to.eql(0);
+        done(err);
+      };
+      stubFetchResponse();
+      stubXhrResponse();
+      server.requests.length = 0;
+      options.transport = 'fetch';
+      t.post(accessToken, options, payload, callback);
+    });
+    it('should use xhr when requested', function(done) {
+      var callback = function(err, resp) {
+        expect(window.fetchStub.called).to.not.be.ok();
+        expect(server.requests.length).to.eql(1);
+        done(err);
+      };
+      stubFetchResponse();
+      stubXhrResponse();
+      server.requests.length = 0;
+      options.transport = 'xhr';
+      t.post(accessToken, options, payload, callback);
+      setTimeout(function() {
+        server.respond();
+      }, 1);
+    });
+  });
 });
 
 var TestRequest = function(response, status, shouldThrowOnSend) {