rollbar 2.25.0 → 2.25.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollbar",
-  "version": "2.25.0",
+  "version": "2.25.2",
   "repository": {
     "type": "git",
     "url": "http://github.com/rollbar/rollbar.js"

package/src/api.js

@@ -47,7 +47,12 @@ function Api(options, transport, urllib, truncation, jsonBackup) {
 Api.prototype.postItem = function(data, callback) {
   var transportOptions = helpers.transportOptions(this.transportOptions, 'POST');
   var payload = helpers.buildPayload(this.accessToken, data, this.jsonBackup);
-  this.transport.post(this.accessToken, transportOptions, payload, callback);
+  var self = this;
+
+  // ensure the network request is scheduled after the current tick.
+  setTimeout(function() {
+    self.transport.post(self.accessToken, transportOptions, payload, callback);
+  }, 0);
 };
 
 /**

package/src/browser/shim.js

@@ -62,9 +62,16 @@ function setupShim(window, options) {
       globals.captureUnhandledRejections(window, handler, true);
     }
 
+    function pageTelemetryEnabled(ai) {
+      if (typeof ai === 'object' && (ai.page === undefined || ai.page)) {
+        return true;
+      }
+      return false;
+    }
+
     var ai = options.autoInstrument;
     if (options.enabled !== false) {
-      if (ai === undefined || ai === true || (typeof ai === 'object' && ai.network)) {
+      if (ai === undefined || ai === true || pageTelemetryEnabled(ai)) {
         if (window.addEventListener) {
           window.addEventListener('load', handler.captureLoad.bind(handler));
           window.addEventListener('DOMContentLoaded', handler.captureDomContentLoaded.bind(handler));

package/src/browser/telemetry.js

@@ -1,4 +1,5 @@
 var _ = require('../utility');
+var headers = require('../utility/headers');
 var scrub = require('../scrub');
 var urlparser = require('./url');
 var domUtil = require('./domUtility');
@@ -362,7 +363,7 @@ Instrumenter.prototype.instrumentNetwork = function() {
         if (args[1] && args[1].headers) {
           // Argument may be a Headers object, or plain object. Ensure here that
           // we are working with a Headers object with case-insensitive keys.
-          var reqHeaders = new Headers(args[1].headers);
+          var reqHeaders = headers(args[1].headers);
 
           metadata.request_content_type = reqHeaders.get('Content-Type');
 

package/src/browser/transforms.js

@@ -79,20 +79,25 @@ function addBaseInfo(item, options, callback) {
 
 function addRequestInfo(window) {
   return function(item, options, callback) {
-    if (!window || !window.location) {
-      return callback(null, item);
+    var requestInfo = {};
+
+    if (window && window.location) {
+      requestInfo.url = window.location.href;
+      requestInfo.query_string = window.location.search;
     }
+
     var remoteString = '$remote_ip';
     if (!options.captureIp) {
       remoteString = null;
     } else if (options.captureIp !== true) {
       remoteString += '_anonymize';
     }
-    _.set(item, 'data.request', {
-      url: window.location.href,
-      query_string: window.location.search,
-      user_ip: remoteString
-    });
+    if (remoteString) requestInfo.user_ip = remoteString;
+
+    if (Object.keys(requestInfo).length > 0) {
+      _.set(item, 'data.request', requestInfo);
+    }
+
     callback(null, item);
   };
 }

package/src/defaults.js

@@ -1,5 +1,5 @@
 module.exports = {
-  version: '2.25.0',
+  version: '2.25.2',
   endpoint: 'api.rollbar.com/api/1/item/',
   logLevel: 'debug',
   reportLevel: 'debug',

package/src/utility/headers.js

@@ -0,0 +1,94 @@
+/*
+ * headers - Detect when fetch Headers are undefined and use a partial polyfill.
+ *
+ * A full polyfill is not used in order to keep package size as small as possible.
+ * Since this is only used internally and is not added to the window object,
+ * the full interface doesn't need to be supported.
+ *
+ * This implementation is modified from whatwg-fetch:
+ * https://github.com/github/fetch
+ */
+function headers(headers) {
+  if (typeof Headers === 'undefined') {
+    return new FetchHeaders(headers);
+  }
+
+  return new Headers(headers);
+}
+
+function normalizeName(name) {
+  if (typeof name !== 'string') {
+    name = String(name)
+  }
+  return name.toLowerCase()
+}
+
+function normalizeValue(value) {
+  if (typeof value !== 'string') {
+    value = String(value)
+  }
+  return value
+}
+
+function iteratorFor(items) {
+  var iterator = {
+    next: function() {
+      var value = items.shift()
+      return {done: value === undefined, value: value}
+    }
+  }
+
+  return iterator
+}
+
+function FetchHeaders(headers) {
+  this.map = {}
+
+  if (headers instanceof FetchHeaders) {
+    headers.forEach(function(value, name) {
+      this.append(name, value)
+    }, this)
+  } else if (Array.isArray(headers)) {
+    headers.forEach(function(header) {
+      this.append(header[0], header[1])
+    }, this)
+  } else if (headers) {
+    Object.getOwnPropertyNames(headers).forEach(function(name) {
+      this.append(name, headers[name])
+    }, this)
+  }
+}
+
+FetchHeaders.prototype.append = function(name, value) {
+  name = normalizeName(name)
+  value = normalizeValue(value)
+  var oldValue = this.map[name]
+  this.map[name] = oldValue ? oldValue + ', ' + value : value
+}
+
+FetchHeaders.prototype.get = function(name) {
+  name = normalizeName(name)
+  return this.has(name) ? this.map[name] : null
+}
+
+FetchHeaders.prototype.has = function(name) {
+  return this.map.hasOwnProperty(normalizeName(name))
+}
+
+FetchHeaders.prototype.forEach = function(callback, thisArg) {
+  for (var name in this.map) {
+    if (this.map.hasOwnProperty(name)) {
+      callback.call(thisArg, this.map[name], name, this)
+    }
+  }
+}
+
+FetchHeaders.prototype.entries = function() {
+  var items = []
+  this.forEach(function(value, name) {
+    items.push([name, value])
+  })
+  return iteratorFor(items)
+}
+
+module.exports = headers;

package/test/browser.core.test.js

@@ -43,23 +43,26 @@ describe('options.captureUncaught', function() {
 
     var element = document.getElementById('throw-error');
     element.click();
-    server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+    setTimeout(function() {
+      server.respond();
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace.exception.message).to.eql('test error');
-    expect(body.data.notifier.diagnostic.raw_error.message).to.eql('test error');
-    expect(body.data.notifier.diagnostic.is_uncaught).to.eql(true);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    // karma doesn't unload the browser between tests, so the onerror handler
-    // will remain installed. Unset captureUncaught so the onerror handler
-    // won't affect other tests.
-    rollbar.configure({
-      captureUncaught: false
-    });
+      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+      expect(body.data.body.trace.exception.message).to.eql('test error');
+      expect(body.data.notifier.diagnostic.raw_error.message).to.eql('test error');
+      expect(body.data.notifier.diagnostic.is_uncaught).to.eql(true);
 
-    done();
+      // karma doesn't unload the browser between tests, so the onerror handler
+      // will remain installed. Unset captureUncaught so the onerror handler
+      // won't affect other tests.
+      rollbar.configure({
+        captureUncaught: false
+      });
+
+      done();
+    }, 1);
   });
 
   it('should respond to enable/disable in configure', function(done) {
@@ -75,34 +78,43 @@ describe('options.captureUncaught', function() {
     var rollbar = window.rollbar = new Rollbar(options);
 
     element.click();
-    server.respond();
-    expect(server.requests.length).to.eql(0); // Disabled, no event
-    server.requests.length = 0;
 
-    rollbar.configure({
-      captureUncaught: true
-    });
+    setTimeout(function() {
+      server.respond();
+      expect(server.requests.length).to.eql(0); // Disabled, no event
+      server.requests.length = 0;
 
-    element.click();
-    server.respond();
+      rollbar.configure({
+        captureUncaught: true
+      });
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      element.click();
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace.exception.message).to.eql('test error');
-    expect(body.data.notifier.diagnostic.is_anonymous).to.not.be.ok();
+      setTimeout(function() {
+        server.respond();
 
-    server.requests.length = 0;
+        var body = JSON.parse(server.requests[0].requestBody);
 
-    rollbar.configure({
-      captureUncaught: false
-    });
+        expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+        expect(body.data.body.trace.exception.message).to.eql('test error');
+        expect(body.data.notifier.diagnostic.is_anonymous).to.not.be.ok();
 
-    element.click();
-    server.respond();
-    expect(server.requests.length).to.eql(0); // Disabled, no event
+        server.requests.length = 0;
 
-    done();
+        rollbar.configure({
+          captureUncaught: false
+        });
+
+        element.click();
+
+        setTimeout(function() {
+          server.respond();
+          expect(server.requests.length).to.eql(0); // Disabled, no event
+
+          done();
+        }, 1);
+      }, 1);
+    }, 1);
   });
 
   // Test case expects Chrome, which is the currently configured karma js/browser
@@ -132,22 +144,24 @@ describe('options.captureUncaught', function() {
       Error.prepareStackTrace(e);
     }
 
-    server.respond();
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace.exception.message).to.eql('anon error');
-    expect(body.data.notifier.diagnostic.is_anonymous).to.eql(true);
+      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+      expect(body.data.body.trace.exception.message).to.eql('anon error');
+      expect(body.data.notifier.diagnostic.is_anonymous).to.eql(true);
 
-    // karma doesn't unload the browser between tests, so the onerror handler
-    // will remain installed. Unset captureUncaught so the onerror handler
-    // won't affect other tests.
-    rollbar.configure({
-      captureUncaught: false
-    });
+      // karma doesn't unload the browser between tests, so the onerror handler
+      // will remain installed. Unset captureUncaught so the onerror handler
+      // won't affect other tests.
+      rollbar.configure({
+        captureUncaught: false
+      });
 
-    done();
+      done();
+    }, 1);
   });
 
   it('should ignore duplicate errors by default', function(done) {
@@ -167,24 +181,27 @@ describe('options.captureUncaught', function() {
     for(var i = 0; i < 2; i++) {
       element.click(); // use for loop to ensure the stack traces have identical line/col info
     }
-    server.respond();
 
-    // transmit only once
-    expect(server.requests.length).to.eql(1);
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      // transmit only once
+      expect(server.requests.length).to.eql(1);
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace.exception.message).to.eql('test error');
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    // karma doesn't unload the browser between tests, so the onerror handler
-    // will remain installed. Unset captureUncaught so the onerror handler
-    // won't affect other tests.
-    rollbar.configure({
-      captureUncaught: false
-    });
+      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+      expect(body.data.body.trace.exception.message).to.eql('test error');
 
-    done();
+      // karma doesn't unload the browser between tests, so the onerror handler
+      // will remain installed. Unset captureUncaught so the onerror handler
+      // won't affect other tests.
+      rollbar.configure({
+        captureUncaught: false
+      });
+
+      done();
+    }, 1);
   });
 
   it('should transmit duplicate errors when set in config', function(done) {
@@ -205,24 +222,27 @@ describe('options.captureUncaught', function() {
     for(var i = 0; i < 2; i++) {
       element.click(); // use for loop to ensure the stack traces have identical line/col info
     }
-    server.respond();
 
-    // transmit both errors
-    expect(server.requests.length).to.eql(2);
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      // transmit both errors
+      expect(server.requests.length).to.eql(2);
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace.exception.message).to.eql('test error');
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    // karma doesn't unload the browser between tests, so the onerror handler
-    // will remain installed. Unset captureUncaught so the onerror handler
-    // won't affect other tests.
-    rollbar.configure({
-      captureUncaught: false
-    });
+      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+      expect(body.data.body.trace.exception.message).to.eql('test error');
 
-    done();
+      // karma doesn't unload the browser between tests, so the onerror handler
+      // will remain installed. Unset captureUncaught so the onerror handler
+      // won't affect other tests.
+      rollbar.configure({
+        captureUncaught: false
+      });
+
+      done();
+    }, 1);
   });
   it('should send DOMException as trace_chain', function(done) {
     var server = window.server;
@@ -237,21 +257,24 @@ describe('options.captureUncaught', function() {
 
     var element = document.getElementById('throw-dom-exception');
     element.click();
-    server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+    setTimeout(function() {
+      server.respond();
+
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace_chain[0].exception.message).to.eql('test DOMException');
+      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+      expect(body.data.body.trace_chain[0].exception.message).to.eql('test DOMException');
 
-    // karma doesn't unload the browser between tests, so the onerror handler
-    // will remain installed. Unset captureUncaught so the onerror handler
-    // won't affect other tests.
-    rollbar.configure({
-      captureUncaught: false
-    });
+      // karma doesn't unload the browser between tests, so the onerror handler
+      // will remain installed. Unset captureUncaught so the onerror handler
+      // won't affect other tests.
+      rollbar.configure({
+        captureUncaught: false
+      });
 
-    done();
+      done();
+    }, 1);
   });
 
   it('should capture exta frames when stackTraceLimit is set', function(done) {
@@ -269,23 +292,26 @@ describe('options.captureUncaught', function() {
 
     var element = document.getElementById('throw-depp-stack-error');
     element.click();
-    server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+    setTimeout(function() {
+      server.respond();
 
-    expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
-    expect(body.data.body.trace.exception.message).to.eql('deep stack error');
-    expect(body.data.body.trace.frames.length).to.be.above(20);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    // karma doesn't unload the browser between tests, so the onerror handler
-    // will remain installed. Unset captureUncaught so the onerror handler
-    // won't affect other tests.
-    rollbar.configure({
-      captureUncaught: false,
-      stackTraceLimit: oldLimit // reset to default
-    });
+      expect(body.access_token).to.eql('POST_CLIENT_ITEM_TOKEN');
+      expect(body.data.body.trace.exception.message).to.eql('deep stack error');
+      expect(body.data.body.trace.frames.length).to.be.above(20);
 
-    done();
+      // karma doesn't unload the browser between tests, so the onerror handler
+      // will remain installed. Unset captureUncaught so the onerror handler
+      // won't affect other tests.
+      rollbar.configure({
+        captureUncaught: false,
+        stackTraceLimit: oldLimit // reset to default
+      });
+
+      done();
+    }, 1);
   });
 });
 
@@ -440,16 +466,18 @@ describe('log', function() {
 
     rollbar.log('test message', { 'foo': 'bar' });
 
-    server.respond();
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.data.body.message.body).to.eql('test message');
-    expect(body.data.body.message.extra).to.eql({ 'foo': 'bar' });
-    expect(body.data.notifier.diagnostic.is_uncaught).to.eql(undefined);
-    expect(body.data.notifier.diagnostic.original_arg_types).to.eql(['string', 'object']);
+      expect(body.data.body.message.body).to.eql('test message');
+      expect(body.data.body.message.extra).to.eql({ 'foo': 'bar' });
+      expect(body.data.notifier.diagnostic.is_uncaught).to.eql(undefined);
+      expect(body.data.notifier.diagnostic.original_arg_types).to.eql(['string', 'object']);
 
-    done();
+      done();
+    }, 1);
   })
 
   it('should send exception when called with error and extra args', function(done) {
@@ -464,16 +492,18 @@ describe('log', function() {
 
     rollbar.log(new Error('test error'), { 'foo': 'bar' });
 
-    server.respond();
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.data.body.trace.exception.message).to.eql('test error');
-    expect(body.data.body.trace.extra).to.eql({ 'foo': 'bar' });
-    expect(body.data.notifier.diagnostic.is_uncaught).to.eql(undefined);
-    expect(body.data.notifier.diagnostic.original_arg_types).to.eql(['error', 'object']);
+      expect(body.data.body.trace.exception.message).to.eql('test error');
+      expect(body.data.body.trace.extra).to.eql({ 'foo': 'bar' });
+      expect(body.data.notifier.diagnostic.is_uncaught).to.eql(undefined);
+      expect(body.data.notifier.diagnostic.original_arg_types).to.eql(['error', 'object']);
 
-    done();
+      done();
+    }, 1);
   })
 
   it('should add custom data when called with error context', function(done) {
@@ -492,15 +522,17 @@ describe('log', function() {
 
     rollbar.error(err, { 'foo': 'bar' });
 
-    server.respond();
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.data.body.trace.exception.message).to.eql('test error');
-    expect(body.data.custom.foo).to.eql('bar');
-    expect(body.data.custom.err).to.eql('test');
+      expect(body.data.body.trace.exception.message).to.eql('test error');
+      expect(body.data.custom.foo).to.eql('bar');
+      expect(body.data.custom.err).to.eql('test');
 
-    done();
+      done();
+    }, 1);
   })
 
   it('should remove circular references in custom data', function(done) {
@@ -529,30 +561,32 @@ describe('log', function() {
     custom.self = custom;
     rollbar.error(err, custom);
 
-    server.respond();
-
-    var body = JSON.parse(server.requests[0].requestBody);
-
-    expect(body.data.body.trace.exception.message).to.eql('test error');
-    expect(body.data.custom.foo).to.eql('bar');
-    expect(body.data.custom.err).to.eql('test');
+    setTimeout(function() {
+      server.respond();
 
-    // Duplicate objects are allowed when there is no circular reference.
-    expect(body.data.custom.notCircular1).to.eql(notCircular);
-    expect(body.data.custom.notCircular2).to.eql(notCircular);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.data.custom.self).to.eql(
-      'Removed circular reference: object'
-    );
-    expect(body.data.custom.array).to.eql([
-      'one', 'two', 'Removed circular reference: array'
-    ]);
-    expect(body.data.custom.contextData).to.eql({
-      extra: 'baz',
-      data: 'Removed circular reference: object'
-    });
+      expect(body.data.body.trace.exception.message).to.eql('test error');
+      expect(body.data.custom.foo).to.eql('bar');
+      expect(body.data.custom.err).to.eql('test');
+
+      // Duplicate objects are allowed when there is no circular reference.
+      expect(body.data.custom.notCircular1).to.eql(notCircular);
+      expect(body.data.custom.notCircular2).to.eql(notCircular);
+
+      expect(body.data.custom.self).to.eql(
+        'Removed circular reference: object'
+      );
+      expect(body.data.custom.array).to.eql([
+        'one', 'two', 'Removed circular reference: array'
+      ]);
+      expect(body.data.custom.contextData).to.eql({
+        extra: 'baz',
+        data: 'Removed circular reference: object'
+      });
 
-    done();
+      done();
+    }, 1);
   })
 
   it('should send message when called with only null arguments', function(done) {
@@ -568,14 +602,16 @@ describe('log', function() {
 
     rollbar.log(null);
 
-    server.respond();
+    setTimeout(function() {
+      server.respond();
 
-    var body = JSON.parse(server.requests[0].requestBody);
+      var body = JSON.parse(server.requests[0].requestBody);
 
-    expect(body.data.body.message.body).to.eql('Item sent with null or missing arguments.');
-    expect(body.data.notifier.diagnostic.original_arg_types).to.eql(['null']);
+      expect(body.data.body.message.body).to.eql('Item sent with null or missing arguments.');
+      expect(body.data.notifier.diagnostic.original_arg_types).to.eql(['null']);
 
-    done();
+      done();
+    }, 1);
   })
 
   it('should skipFrames when set', function(done) {
@@ -594,14 +630,16 @@ describe('log', function() {
     rollbar.log(error);
     rollbar.log(error, { skipFrames: 1 });
 
-    server.respond();
+    setTimeout(function() {
+      server.respond();
 
-    var frames1 = JSON.parse(server.requests[0].requestBody).data.body.trace.frames;
-    var frames2 = JSON.parse(server.requests[1].requestBody).data.body.trace.frames;
+      var frames1 = JSON.parse(server.requests[0].requestBody).data.body.trace.frames;
+      var frames2 = JSON.parse(server.requests[1].requestBody).data.body.trace.frames;
 
-    expect(frames1.length).to.eql(frames2.length + 1);
-    expect(frames1.slice(0,-1)).to.eql(frames2);
+      expect(frames1.length).to.eql(frames2.length + 1);
+      expect(frames1.slice(0,-1)).to.eql(frames2);
 
-    done();
+      done();
+    }, 1);
   })
 });