rollbar 2.26.2 → 2.26.4

package/src/telemetry.js

@@ -9,7 +9,7 @@ function Telemeter(options) {
   this.maxQueueSize = Math.max(0, Math.min(maxTelemetryEvents, MAX_EVENTS));
 }
 
-Telemeter.prototype.configure = function(options) {
+Telemeter.prototype.configure = function (options) {
   var oldOptions = this.options;
   this.options = _.merge(oldOptions, options);
   var maxTelemetryEvents = this.options.maxTelemetryEvents || MAX_EVENTS;
@@ -22,7 +22,7 @@ Telemeter.prototype.configure = function(options) {
   this.queue.splice(0, deleteCount);
 };
 
-Telemeter.prototype.copyEvents = function() {
+Telemeter.prototype.copyEvents = function () {
   var events = Array.prototype.slice.call(this.queue, 0);
   if (_.isFunction(this.options.filterTelemetry)) {
     try {
@@ -39,20 +39,29 @@ Telemeter.prototype.copyEvents = function() {
   return events;
 };
 
-Telemeter.prototype.capture = function(type, metadata, level, rollbarUUID, timestamp) {
+Telemeter.prototype.capture = function (
+  type,
+  metadata,
+  level,
+  rollbarUUID,
+  timestamp,
+) {
   var e = {
     level: getLevel(type, level),
     type: type,
     timestamp_ms: timestamp || _.now(),
     body: metadata,
-    source: 'client'
+    source: 'client',
   };
   if (rollbarUUID) {
     e.uuid = rollbarUUID;
   }
 
   try {
-    if (_.isFunction(this.options.filterTelemetry) && this.options.filterTelemetry(e)) {
+    if (
+      _.isFunction(this.options.filterTelemetry) &&
+      this.options.filterTelemetry(e)
+    ) {
       return false;
     }
   } catch (exc) {
@@ -63,13 +72,23 @@ Telemeter.prototype.capture = function(type, metadata, level, rollbarUUID, times
   return e;
 };
 
-Telemeter.prototype.captureEvent = function(type, metadata, level, rollbarUUID) {
+Telemeter.prototype.captureEvent = function (
+  type,
+  metadata,
+  level,
+  rollbarUUID,
+) {
   return this.capture(type, metadata, level, rollbarUUID);
 };
 
-Telemeter.prototype.captureError = function(err, level, rollbarUUID, timestamp) {
+Telemeter.prototype.captureError = function (
+  err,
+  level,
+  rollbarUUID,
+  timestamp,
+) {
   var metadata = {
-    message: err.message || String(err)
+    message: err.message || String(err),
   };
   if (err.stack) {
     metadata.stack = err.stack;
@@ -77,13 +96,29 @@ Telemeter.prototype.captureError = function(err, level, rollbarUUID, timestamp)
   return this.capture('error', metadata, level, rollbarUUID, timestamp);
 };
 
-Telemeter.prototype.captureLog = function(message, level, rollbarUUID, timestamp) {
-  return this.capture('log', {
-    message: message
-  }, level, rollbarUUID, timestamp);
+Telemeter.prototype.captureLog = function (
+  message,
+  level,
+  rollbarUUID,
+  timestamp,
+) {
+  return this.capture(
+    'log',
+    {
+      message: message,
+    },
+    level,
+    rollbarUUID,
+    timestamp,
+  );
 };
 
-Telemeter.prototype.captureNetwork = function(metadata, subtype, rollbarUUID, requestData) {
+Telemeter.prototype.captureNetwork = function (
+  metadata,
+  subtype,
+  rollbarUUID,
+  requestData,
+) {
   subtype = subtype || 'xhr';
   metadata.subtype = metadata.subtype || subtype;
   if (requestData) {
@@ -93,7 +128,7 @@ Telemeter.prototype.captureNetwork = function(metadata, subtype, rollbarUUID, re
   return this.capture('network', metadata, level, rollbarUUID);
 };
 
-Telemeter.prototype.levelFromStatus = function(statusCode) {
+Telemeter.prototype.levelFromStatus = function (statusCode) {
   if (statusCode >= 200 && statusCode < 400) {
     return 'info';
   }
@@ -103,10 +138,16 @@ Telemeter.prototype.levelFromStatus = function(statusCode) {
   return 'info';
 };
 
-Telemeter.prototype.captureDom = function(subtype, element, value, checked, rollbarUUID) {
+Telemeter.prototype.captureDom = function (
+  subtype,
+  element,
+  value,
+  checked,
+  rollbarUUID,
+) {
   var metadata = {
     subtype: subtype,
-    element: element
+    element: element,
   };
   if (value !== undefined) {
     metadata.value = value;
@@ -117,31 +158,48 @@ Telemeter.prototype.captureDom = function(subtype, element, value, checked, roll
   return this.capture('dom', metadata, 'info', rollbarUUID);
 };
 
-Telemeter.prototype.captureNavigation = function(from, to, rollbarUUID) {
-  return this.capture('navigation', {from: from, to: to}, 'info', rollbarUUID);
+Telemeter.prototype.captureNavigation = function (from, to, rollbarUUID) {
+  return this.capture(
+    'navigation',
+    { from: from, to: to },
+    'info',
+    rollbarUUID,
+  );
 };
 
-Telemeter.prototype.captureDomContentLoaded = function(ts) {
-  return this.capture('navigation', {subtype: 'DOMContentLoaded'}, 'info', undefined, ts && ts.getTime());
+Telemeter.prototype.captureDomContentLoaded = function (ts) {
+  return this.capture(
+    'navigation',
+    { subtype: 'DOMContentLoaded' },
+    'info',
+    undefined,
+    ts && ts.getTime(),
+  );
   /**
    * If we decide to make this a dom event instead, then use the line below:
   return this.capture('dom', {subtype: 'DOMContentLoaded'}, 'info', undefined, ts && ts.getTime());
   */
 };
-Telemeter.prototype.captureLoad = function(ts) {
-  return this.capture('navigation', {subtype: 'load'}, 'info', undefined, ts && ts.getTime());
+Telemeter.prototype.captureLoad = function (ts) {
+  return this.capture(
+    'navigation',
+    { subtype: 'load' },
+    'info',
+    undefined,
+    ts && ts.getTime(),
+  );
   /**
    * If we decide to make this a dom event instead, then use the line below:
   return this.capture('dom', {subtype: 'load'}, 'info', undefined, ts && ts.getTime());
   */
 };
 
-Telemeter.prototype.captureConnectivityChange = function(type, rollbarUUID) {
-  return this.captureNetwork({change: type}, 'connectivity', rollbarUUID);
+Telemeter.prototype.captureConnectivityChange = function (type, rollbarUUID) {
+  return this.captureNetwork({ change: type }, 'connectivity', rollbarUUID);
 };
 
 // Only intended to be used internally by the notifier
-Telemeter.prototype._captureRollbarItem = function(item) {
+Telemeter.prototype._captureRollbarItem = function (item) {
   if (!this.options.includeItemsInTelemetry) {
     return;
   }
@@ -152,11 +210,17 @@ Telemeter.prototype._captureRollbarItem = function(item) {
     return this.captureLog(item.message, item.level, item.uuid, item.timestamp);
   }
   if (item.custom) {
-    return this.capture('log', item.custom, item.level, item.uuid, item.timestamp);
+    return this.capture(
+      'log',
+      item.custom,
+      item.level,
+      item.uuid,
+      item.timestamp,
+    );
   }
 };
 
-Telemeter.prototype.push = function(e) {
+Telemeter.prototype.push = function (e) {
   this.queue.push(e);
   if (this.queue.length > this.maxQueueSize) {
     this.queue.shift();
@@ -169,7 +233,7 @@ function getLevel(type, level) {
   }
   var defaultLevel = {
     error: 'error',
-    manual: 'info'
+    manual: 'info',
   };
   return defaultLevel[type] || 'info';
 }

package/src/transforms.js

@@ -42,19 +42,19 @@ function addMessageWithError(item, options, callback) {
   }
   if (trace) {
     if (!(trace.exception && trace.exception.description)) {
-      _.set(item, tracePath+'.exception.description', item.message);
+      _.set(item, tracePath + '.exception.description', item.message);
       callback(null, item);
       return;
     }
-    var extra = _.get(item, tracePath+'.extra') || {};
-    var newExtra =  _.merge(extra, {message: item.message});
-    _.set(item, tracePath+'.extra', newExtra);
+    var extra = _.get(item, tracePath + '.extra') || {};
+    var newExtra = _.merge(extra, { message: item.message });
+    _.set(item, tracePath + '.extra', newExtra);
   }
   callback(null, item);
 }
 
 function userTransform(logger) {
-  return function(item, options, callback) {
+  return function (item, options, callback) {
     var newItem = _.merge(item);
     var response = null;
     try {
@@ -63,23 +63,29 @@ function userTransform(logger) {
       }
     } catch (e) {
       options.transform = null;
-      logger.error('Error while calling custom transform() function. Removing custom transform().', e);
+      logger.error(
+        'Error while calling custom transform() function. Removing custom transform().',
+        e,
+      );
       callback(null, item);
       return;
     }
-    if(_.isPromise(response)) {
-      response.then(function (promisedItem) {
-        if(promisedItem) {
-          newItem.data = promisedItem;
-        }
-        callback(null, newItem);
-      }, function (error) {
-        callback(error, item);
-      });
+    if (_.isPromise(response)) {
+      response.then(
+        function (promisedItem) {
+          if (promisedItem) {
+            newItem.data = promisedItem;
+          }
+          callback(null, newItem);
+        },
+        function (error) {
+          callback(error, item);
+        },
+      );
     } else {
       callback(null, newItem);
     }
-  }
+  };
 }
 
 function addConfigToPayload(item, options, callback) {
@@ -94,7 +100,7 @@ function addConfigToPayload(item, options, callback) {
 }
 
 function addFunctionOption(options, name) {
-  if(_.isFunction(options[name])) {
+  if (_.isFunction(options[name])) {
     options[name] = options[name].toString();
   }
 }
@@ -113,7 +119,10 @@ function addConfiguredOptions(item, options, callback) {
 }
 
 function addDiagnosticKeys(item, options, callback) {
-  var diagnostic = _.merge(item.notifier.client.notifier.diagnostic, item.diagnostic);
+  var diagnostic = _.merge(
+    item.notifier.client.notifier.diagnostic,
+    item.diagnostic,
+  );
 
   if (_.get(item, 'err._isAnonymous')) {
     diagnostic.is_anonymous = true;
@@ -132,14 +141,17 @@ function addDiagnosticKeys(item, options, callback) {
         filename: item.err.fileName,
         line: item.err.lineNumber,
         column: item.err.columnNumber,
-        stack: item.err.stack
+        stack: item.err.stack,
       };
     } catch (e) {
       diagnostic.raw_error = { failed: String(e) };
     }
   }
 
-  item.data.notifier.diagnostic = _.merge(item.data.notifier.diagnostic, diagnostic);
+  item.data.notifier.diagnostic = _.merge(
+    item.data.notifier.diagnostic,
+    diagnostic,
+  );
   callback(null, item);
 }
 
@@ -151,5 +163,5 @@ module.exports = {
   userTransform: userTransform,
   addConfigToPayload: addConfigToPayload,
   addConfiguredOptions: addConfiguredOptions,
-  addDiagnosticKeys: addDiagnosticKeys
+  addDiagnosticKeys: addDiagnosticKeys,
 };

package/src/truncation.js

@@ -14,7 +14,7 @@ function selectFrames(frames, range) {
 }
 
 function truncateFrames(payload, jsonBackup, range) {
-  range = (typeof range === 'undefined') ? 30 : range;
+  range = typeof range === 'undefined' ? 30 : range;
   var body = payload.data.body;
   var frames;
   if (body.trace_chain) {
@@ -61,7 +61,10 @@ function truncateStrings(len, payload, jsonBackup) {
 function truncateTraceData(traceData) {
   if (traceData.exception) {
     delete traceData.exception.description;
-    traceData.exception.message = maybeTruncateValue(255, traceData.exception.message);
+    traceData.exception.message = maybeTruncateValue(
+      255,
+      traceData.exception.message,
+    );
   }
   traceData.frames = selectFrames(traceData.frames, 1);
   return traceData;
@@ -85,14 +88,14 @@ function needsTruncation(payload, maxSize) {
 }
 
 function truncate(payload, jsonBackup, maxSize) {
-  maxSize = (typeof maxSize === 'undefined') ? (512 * 1024) : maxSize;
+  maxSize = typeof maxSize === 'undefined' ? 512 * 1024 : maxSize;
   var strategies = [
     raw,
     truncateFrames,
     truncateStrings.bind(null, 1024),
     truncateStrings.bind(null, 512),
     truncateStrings.bind(null, 256),
-    minBody
+    minBody,
   ];
   var strategy, results, result;
 
@@ -114,5 +117,5 @@ module.exports = {
   raw: raw,
   truncateFrames: truncateFrames,
   truncateStrings: truncateStrings,
-  maybeTruncateValue: maybeTruncateValue
+  maybeTruncateValue: maybeTruncateValue,
 };

package/src/utility/headers.js

@@ -18,77 +18,77 @@ function headers(headers) {
 
 function normalizeName(name) {
   if (typeof name !== 'string') {
-    name = String(name)
+    name = String(name);
   }
-  return name.toLowerCase()
+  return name.toLowerCase();
 }
 
 function normalizeValue(value) {
   if (typeof value !== 'string') {
-    value = String(value)
+    value = String(value);
   }
-  return value
+  return value;
 }
 
 function iteratorFor(items) {
   var iterator = {
-    next: function() {
-      var value = items.shift()
-      return {done: value === undefined, value: value}
-    }
-  }
+    next: function () {
+      var value = items.shift();
+      return { done: value === undefined, value: value };
+    },
+  };
 
-  return iterator
+  return iterator;
 }
 
 function FetchHeaders(headers) {
-  this.map = {}
+  this.map = {};
 
   if (headers instanceof FetchHeaders) {
-    headers.forEach(function(value, name) {
-      this.append(name, value)
-    }, this)
+    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)
+    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)
+    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.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.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.has = function (name) {
+  return this.map.hasOwnProperty(normalizeName(name));
+};
 
-FetchHeaders.prototype.forEach = function(callback, thisArg) {
+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)
+      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)
-}
+FetchHeaders.prototype.entries = function () {
+  var items = [];
+  this.forEach(function (value, name) {
+    items.push([name, value]);
+  });
+  return iteratorFor(items);
+};
 
 module.exports = headers;

package/src/utility/replace.js

@@ -0,0 +1,9 @@
+function replace(obj, name, replacement, replacements, type) {
+  var orig = obj[name];
+  obj[name] = replacement(orig);
+  if (replacements) {
+    replacements[type].push([obj, name, orig]);
+  }
+}
+
+module.exports = replace;

package/src/utility/traverse.js

@@ -8,7 +8,7 @@ function traverse(obj, func, seen) {
   var seenIndex;
 
   // Best might be to use Map here with `obj` as the keys, but we want to support IE < 11.
-  seen = seen || { obj: [], mapped: []};
+  seen = seen || { obj: [], mapped: [] };
 
   if (isObj) {
     seenIndex = seen.obj.indexOf(obj);