rollbar 2.26.3 → 3.0.0-alpha.1

package/src/defaults.js

@@ -1,9 +1,9 @@
 module.exports = {
-  version: '2.26.3',
+  version: '3.0.0-alpha.1',
   endpoint: 'api.rollbar.com/api/1/item/',
   logLevel: 'debug',
   reportLevel: 'debug',
   uncaughtErrorLevel: 'error',
   maxItems: 0,
-  itemsPerMin: 60
-}
+  itemsPerMin: 60,
+};

package/src/errorParser.js

@@ -1,18 +1,18 @@
 var ErrorStackParser = require('error-stack-parser');
 
 var UNKNOWN_FUNCTION = '?';
-var ERR_CLASS_REGEXP = new RegExp('^(([a-zA-Z0-9-_$ ]*): *)?(Uncaught )?([a-zA-Z0-9-_$ ]*): ');
+var ERR_CLASS_REGEXP = new RegExp(
+  '^(([a-zA-Z0-9-_$ ]*): *)?(Uncaught )?([a-zA-Z0-9-_$ ]*): ',
+);
 
 function guessFunctionName() {
   return UNKNOWN_FUNCTION;
 }
 
-
 function gatherContext() {
   return null;
 }
 
-
 function Frame(stackFrame) {
   var data = {};
 
@@ -29,7 +29,6 @@ function Frame(stackFrame) {
   return data;
 }
 
-
 function Stack(exception, skip) {
   function getStack() {
     var parserStack = [];
@@ -38,7 +37,7 @@ function Stack(exception, skip) {
 
     try {
       parserStack = ErrorStackParser.parse(exception);
-    } catch(e) {
+    } catch (e) {
       parserStack = [];
     }
 
@@ -56,11 +55,10 @@ function Stack(exception, skip) {
     message: exception.message,
     name: _mostSpecificErrorName(exception),
     rawStack: exception.stack,
-    rawException: exception
+    rawException: exception,
   };
 }
 
-
 function parse(e, skip) {
   var err = e;
 
@@ -81,7 +79,6 @@ function parse(e, skip) {
   }
 }
 
-
 function guessErrorClass(errMsg) {
   if (!errMsg || !errMsg.match) {
     return ['Unknown error. There was no error message to display.', ''];
@@ -91,7 +88,10 @@ function guessErrorClass(errMsg) {
 
   if (errClassMatch) {
     errClass = errClassMatch[errClassMatch.length - 1];
-    errMsg = errMsg.replace((errClassMatch[errClassMatch.length - 2] || '') + errClass + ':', '');
+    errMsg = errMsg.replace(
+      (errClassMatch[errClassMatch.length - 2] || '') + errClass + ':',
+      '',
+    );
     errMsg = errMsg.replace(/(^[\s]+|[\s]+$)/g, '');
   }
   return [errClass, errMsg];
@@ -102,7 +102,10 @@ function guessErrorClass(errMsg) {
 // * Prefers name over constructor.name when both are more specific than 'Error'
 function _mostSpecificErrorName(error) {
   var name = error.name && error.name.length && error.name;
-  var constructorName = error.constructor.name && error.constructor.name.length && error.constructor.name;
+  var constructorName =
+    error.constructor.name &&
+    error.constructor.name.length &&
+    error.constructor.name;
 
   if (!name || !constructorName) {
     return name || constructorName;
@@ -120,5 +123,5 @@ module.exports = {
   gatherContext: gatherContext,
   parse: parse,
   Stack: Stack,
-  Frame: Frame
+  Frame: Frame,
 };

package/src/merge.js

@@ -4,32 +4,41 @@ var hasOwn = Object.prototype.hasOwnProperty;
 var toStr = Object.prototype.toString;
 
 var isPlainObject = function isPlainObject(obj) {
-	if (!obj || toStr.call(obj) !== '[object Object]') {
-		return false;
-	}
-
-	var hasOwnConstructor = hasOwn.call(obj, 'constructor');
-	var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
-	// Not own constructor property must be Object
-	if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
-		return false;
-	}
-
-	// Own properties are enumerated firstly, so to speed up,
-	// if last one is own, then all properties are own.
-	var key;
-	for (key in obj) {/**/}
-
-	return typeof key === 'undefined' || hasOwn.call(obj, key);
+  if (!obj || toStr.call(obj) !== '[object Object]') {
+    return false;
+  }
+
+  var hasOwnConstructor = hasOwn.call(obj, 'constructor');
+  var hasIsPrototypeOf =
+    obj.constructor &&
+    obj.constructor.prototype &&
+    hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+  // Not own constructor property must be Object
+  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+    return false;
+  }
+
+  // Own properties are enumerated firstly, so to speed up,
+  // if last one is own, then all properties are own.
+  var key;
+  for (key in obj) {
+    /**/
+  }
+
+  return typeof key === 'undefined' || hasOwn.call(obj, key);
 };
 
 function merge() {
-  var i, src, copy, clone, name,
-      result = {},
-     current = null,
-      length = arguments.length;
-
-  for (i=0; i < length; i++) {
+  var i,
+    src,
+    copy,
+    clone,
+    name,
+    result = {},
+    current = null,
+    length = arguments.length;
+
+  for (i = 0; i < length; i++) {
     current = arguments[i];
     if (current == null) {
       continue;

package/src/notifier.js

@@ -22,7 +22,7 @@ function Notifier(queue, options) {
  * @param options - an object which gets merged with the current options set on this notifier
  * @returns this
  */
-Notifier.prototype.configure = function(options) {
+Notifier.prototype.configure = function (options) {
   this.queue && this.queue.configure(options);
   var oldOptions = this.options;
   this.options = _.merge(oldOptions, options);
@@ -40,7 +40,7 @@ Notifier.prototype.configure = function(options) {
  *    with an error to terminate the processing. The item should be the updated item after this
  *    transform is finished modifying it.
  */
-Notifier.prototype.addTransform = function(transform) {
+Notifier.prototype.addTransform = function (transform) {
   if (_.isFunction(transform)) {
     this.transforms.push(transform);
   }
@@ -60,9 +60,9 @@ Notifier.prototype.addTransform = function(transform) {
  * transform stage if an error occurs inside a transform, or in response to the communication with
  * the backend. The second argument will be the response from the backend in case of success.
  */
-Notifier.prototype.log = function(item, callback) {
+Notifier.prototype.log = function (item, callback) {
   if (!callback || !_.isFunction(callback)) {
-    callback = function() {};
+    callback = function () {};
   }
 
   if (!this.options.enabled) {
@@ -71,13 +71,16 @@ Notifier.prototype.log = function(item, callback) {
 
   this.queue.addPendingItem(item);
   var originalError = item.err;
-  this._applyTransforms(item, function(err, i) {
-    if (err) {
-      this.queue.removePendingItem(item);
-      return callback(err, null);
-    }
-    this.queue.addItem(i, callback, originalError, item);
-  }.bind(this));
+  this._applyTransforms(
+    item,
+    function (err, i) {
+      if (err) {
+        this.queue.removePendingItem(item);
+        return callback(err, null);
+      }
+      this.queue.addItem(i, callback, originalError, item);
+    }.bind(this),
+  );
 };
 
 /* Internal */
@@ -91,13 +94,13 @@ Notifier.prototype.log = function(item, callback) {
  * error and a null item in the case of a transform failure, or a null error and non-null item after
  * all transforms have been applied.
  */
-Notifier.prototype._applyTransforms = function(item, callback) {
+Notifier.prototype._applyTransforms = function (item, callback) {
   var transformIndex = -1;
   var transformsLength = this.transforms.length;
   var transforms = this.transforms;
   var options = this.options;
 
-  var cb = function(err, i) {
+  var cb = function (err, i) {
     if (err) {
       callback(err, null);
       return;

package/src/predicates.js

@@ -13,7 +13,7 @@ function checkLevel(item, settings) {
 }
 
 function userCheckIgnore(logger) {
-  return function(item, settings) {
+  return function (item, settings) {
     var isUncaught = !!item._isUncaught;
     delete item._isUncaught;
     var args = item._originalArgs;
@@ -27,7 +27,10 @@ function userCheckIgnore(logger) {
       logger.error('Error while calling onSendCallback, removing', e);
     }
     try {
-      if (_.isFunction(settings.checkIgnore) && settings.checkIgnore(isUncaught, args, item)) {
+      if (
+        _.isFunction(settings.checkIgnore) &&
+        settings.checkIgnore(isUncaught, args, item)
+      ) {
         return false;
       }
     } catch (e) {
@@ -35,27 +38,31 @@ function userCheckIgnore(logger) {
       logger.error('Error while calling custom checkIgnore(), removing', e);
     }
     return true;
-  }
+  };
 }
 
 function urlIsNotBlockListed(logger) {
-  return function(item, settings) {
+  return function (item, settings) {
     return !urlIsOnAList(item, settings, 'blocklist', logger);
-  }
+  };
 }
 
 function urlIsSafeListed(logger) {
-  return function(item, settings) {
+  return function (item, settings) {
     return urlIsOnAList(item, settings, 'safelist', logger);
-  }
+  };
 }
 
 function matchFrames(trace, list, block) {
-  if (!trace) { return !block }
+  if (!trace) {
+    return !block;
+  }
 
   var frames = trace.frames;
 
-  if (!frames || frames.length === 0) { return !block; }
+  if (!frames || frames.length === 0) {
+    return !block;
+  }
 
   var frame, filename, url, urlRegex;
   var listLength = list.length;
@@ -64,7 +71,9 @@ function matchFrames(trace, list, block) {
     frame = frames[i];
     filename = frame.filename;
 
-    if (!_.isType(filename, 'string')) { return !block; }
+    if (!_.isType(filename, 'string')) {
+      return !block;
+    }
 
     for (var j = 0; j < listLength; j++) {
       url = list[j];
@@ -101,27 +110,35 @@ function urlIsOnAList(item, settings, safeOrBlock, logger) {
 
     var tracesLength = traces.length;
     for (var i = 0; i < tracesLength; i++) {
-      if(matchFrames(traces[i], list, block)) {
+      if (matchFrames(traces[i], list, block)) {
         return true;
       }
     }
-  } catch (e)
-  /* istanbul ignore next */
-  {
+  } catch (
+    e
+    /* istanbul ignore next */
+  ) {
     if (block) {
       settings.hostBlockList = null;
     } else {
       settings.hostSafeList = null;
     }
     var listName = block ? 'hostBlockList' : 'hostSafeList';
-    logger.error('Error while reading your configuration\'s ' + listName + ' option. Removing custom ' + listName + '.', e);
+    logger.error(
+      "Error while reading your configuration's " +
+        listName +
+        ' option. Removing custom ' +
+        listName +
+        '.',
+      e,
+    );
     return !block;
   }
   return false;
 }
 
 function messageIsIgnored(logger) {
-  return function(item, settings) {
+  return function (item, settings) {
     var i, j, ignoredMessages, len, messageIsIgnored, rIgnoredMessage, messages;
 
     try {
@@ -134,7 +151,7 @@ function messageIsIgnored(logger) {
 
       messages = messagesFromItem(item);
 
-      if (messages.length === 0){
+      if (messages.length === 0) {
         return true;
       }
 
@@ -150,15 +167,18 @@ function messageIsIgnored(logger) {
           }
         }
       }
-    } catch(e)
-    /* istanbul ignore next */
-    {
+    } catch (
+      e
+      /* istanbul ignore next */
+    ) {
       settings.ignoredMessages = null;
-      logger.error('Error while reading your configuration\'s ignoredMessages option. Removing custom ignoredMessages.');
+      logger.error(
+        "Error while reading your configuration's ignoredMessages option. Removing custom ignoredMessages.",
+      );
     }
 
     return true;
-  }
+  };
 }
 
 function messagesFromItem(item) {
@@ -189,5 +209,5 @@ module.exports = {
   userCheckIgnore: userCheckIgnore,
   urlIsNotBlockListed: urlIsNotBlockListed,
   urlIsSafeListed: urlIsSafeListed,
-  messageIsIgnored: messageIsIgnored
+  messageIsIgnored: messageIsIgnored,
 };

package/src/queue.js

@@ -12,12 +12,14 @@ var _ = require('./utility');
  *    api.postItem(payload, function(err, response))
  * @param logger - An object used to log verbose messages if desired
  * @param options - see Queue.prototype.configure
+ * @param replayMap - Optional ReplayMap for coordinating session replay with error occurrences
  */
-function Queue(rateLimiter, api, logger, options) {
+function Queue(rateLimiter, api, logger, options, replayMap) {
   this.rateLimiter = rateLimiter;
   this.api = api;
   this.logger = logger;
   this.options = options;
+  this.replayMap = replayMap;
   this.predicates = [];
   this.pendingItems = [];
   this.pendingRequests = [];
@@ -32,7 +34,7 @@ function Queue(rateLimiter, api, logger, options) {
  *
  * @param options
  */
-Queue.prototype.configure = function(options) {
+Queue.prototype.configure = function (options) {
   this.api && this.api.configure(options);
   var oldOptions = this.options;
   this.options = _.merge(oldOptions, options);
@@ -48,18 +50,18 @@ Queue.prototype.configure = function(options) {
  *  Returning {err: Error} means do not add the item to the queue, and the given error explains why
  *  Returning {err: undefined} is equivalent to returning true but don't do that
  */
-Queue.prototype.addPredicate = function(predicate) {
+Queue.prototype.addPredicate = function (predicate) {
   if (_.isFunction(predicate)) {
     this.predicates.push(predicate);
   }
   return this;
 };
 
-Queue.prototype.addPendingItem = function(item) {
+Queue.prototype.addPendingItem = function (item) {
   this.pendingItems.push(item);
 };
 
-Queue.prototype.removePendingItem = function(item) {
+Queue.prototype.removePendingItem = function (item) {
   var idx = this.pendingItems.indexOf(item);
   if (idx !== -1) {
     this.pendingItems.splice(idx, 1);
@@ -76,9 +78,16 @@ Queue.prototype.removePendingItem = function(item) {
  *  to be an error condition, but nonetheless did not send the item to the API.
  *  @param originalError - The original error before any transformations that is to be logged if any
  */
-Queue.prototype.addItem = function(item, callback, originalError, originalItem) {
+Queue.prototype.addItem = function (
+  item,
+  callback,
+  originalError,
+  originalItem,
+) {
   if (!callback || !_.isFunction(callback)) {
-    callback = function() { return; };
+    callback = function () {
+      return;
+    };
   }
   var predicateResult = this._applyPredicates(item);
   if (predicateResult.stop) {
@@ -92,12 +101,28 @@ Queue.prototype.addItem = function(item, callback, originalError, originalItem)
     callback(new Error('Transmit disabled'));
     return;
   }
+
+  if (this.replayMap && item.body) {
+    const replayId = _.getItemAttribute(item, 'replay_id');
+    if (replayId) {
+      item.replayId = this.replayMap.add(replayId, item.uuid);
+    }
+  }
+
   this.pendingRequests.push(item);
   try {
-    this._makeApiRequest(item, function(err, resp) {
-      this._dequeuePendingRequest(item);
-      callback(err, resp);
-    }.bind(this));
+    this._makeApiRequest(
+      item,
+      function (err, resp, headers) {
+        this._dequeuePendingRequest(item);
+
+        if (!err && resp && item.replayId) {
+          this._handleReplayResponse(item.replayId, resp, headers);
+        }
+
+        callback(err, resp);
+      }.bind(this),
+    );
   } catch (e) {
     this._dequeuePendingRequest(item);
     callback(e);
@@ -110,7 +135,7 @@ Queue.prototype.addItem = function(item, callback, originalError, originalItem)
  *
  * @param callback - function() called when all pending items have been sent
  */
-Queue.prototype.wait = function(callback) {
+Queue.prototype.wait = function (callback) {
   if (!_.isFunction(callback)) {
     return;
   }
@@ -121,9 +146,12 @@ Queue.prototype.wait = function(callback) {
   if (this.waitIntervalID) {
     this.waitIntervalID = clearInterval(this.waitIntervalID);
   }
-  this.waitIntervalID = setInterval(function() {
-    this._maybeCallWait();
-  }.bind(this), 500);
+  this.waitIntervalID = setInterval(
+    function () {
+      this._maybeCallWait();
+    }.bind(this),
+    500,
+  );
 };
 
 /* _applyPredicates - Sequentially applies the predicates that have been added to the queue to the
@@ -133,15 +161,15 @@ Queue.prototype.wait = function(callback) {
  * @returns {stop: bool, err: (Error|null)} - stop being true means do not add item to the queue,
  *   the error value should be passed up to a callbak if we are stopping.
  */
-Queue.prototype._applyPredicates = function(item) {
+Queue.prototype._applyPredicates = function (item) {
   var p = null;
   for (var i = 0, len = this.predicates.length; i < len; i++) {
     p = this.predicates[i](item, this.options);
     if (!p || p.err !== undefined) {
-      return {stop: true, err: p.err};
+      return { stop: true, err: p.err };
     }
   }
-  return {stop: false, err: null};
+  return { stop: false, err: null };
 };
 
 /*
@@ -151,16 +179,19 @@ Queue.prototype._applyPredicates = function(item) {
  * @param item - an item ready to send to the backend
  * @param callback - function(err, response)
  */
-Queue.prototype._makeApiRequest = function(item, callback) {
+Queue.prototype._makeApiRequest = function (item, callback) {
   var rateLimitResponse = this.rateLimiter.shouldSend(item);
   if (rateLimitResponse.shouldSend) {
-    this.api.postItem(item, function(err, resp) {
-      if (err) {
-        this._maybeRetry(err, item, callback);
-      } else {
-        callback(err, resp);
-      }
-    }.bind(this));
+    this.api.postItem(
+      item,
+      function (err, resp, headers) {
+        if (err) {
+          this._maybeRetry(err, item, callback);
+        } else {
+          callback(err, resp, headers);
+        }
+      }.bind(this),
+    );
   } else if (rateLimitResponse.error) {
     callback(rateLimitResponse.error);
   } else {
@@ -169,7 +200,16 @@ Queue.prototype._makeApiRequest = function(item, callback) {
 };
 
 // These are errors basically mean there is no internet connection
-var RETRIABLE_ERRORS = ['ECONNRESET', 'ENOTFOUND', 'ESOCKETTIMEDOUT', 'ETIMEDOUT', 'ECONNREFUSED', 'EHOSTUNREACH', 'EPIPE', 'EAI_AGAIN'];
+var RETRIABLE_ERRORS = [
+  'ECONNRESET',
+  'ENOTFOUND',
+  'ESOCKETTIMEDOUT',
+  'ETIMEDOUT',
+  'ECONNREFUSED',
+  'EHOSTUNREACH',
+  'EPIPE',
+  'EAI_AGAIN',
+];
 
 /*
  * _maybeRetry - Given the error returned by the API, decide if we should retry or just callback
@@ -179,7 +219,7 @@ var RETRIABLE_ERRORS = ['ECONNRESET', 'ENOTFOUND', 'ESOCKETTIMEDOUT', 'ETIMEDOUT
  * @param item - the item that was trying to be sent when this error occured
  * @param callback - function(err, response)
  */
-Queue.prototype._maybeRetry = function(err, item, callback) {
+Queue.prototype._maybeRetry = function (err, item, callback) {
   var shouldRetry = false;
   if (this.options.retryInterval) {
     for (var i = 0, len = RETRIABLE_ERRORS.length; i < len; i++) {
@@ -209,16 +249,19 @@ Queue.prototype._maybeRetry = function(err, item, callback) {
  * @param item - an item that failed to send due to an error we deem retriable
  * @param callback - function(err, response)
  */
-Queue.prototype._retryApiRequest = function(item, callback) {
-  this.retryQueue.push({item: item, callback: callback});
+Queue.prototype._retryApiRequest = function (item, callback) {
+  this.retryQueue.push({ item: item, callback: callback });
 
   if (!this.retryHandle) {
-    this.retryHandle = setInterval(function() {
-      while (this.retryQueue.length) {
-        var retryObject = this.retryQueue.shift();
-        this._makeApiRequest(retryObject.item, retryObject.callback);
-      }
-    }.bind(this), this.options.retryInterval);
+    this.retryHandle = setInterval(
+      function () {
+        while (this.retryQueue.length) {
+          var retryObject = this.retryQueue.shift();
+          this._makeApiRequest(retryObject.item, retryObject.callback);
+        }
+      }.bind(this),
+      this.options.retryInterval,
+    );
   }
 };
 
@@ -230,7 +273,7 @@ Queue.prototype._retryApiRequest = function(item, callback) {
  *
  * @param item - the item previously added to the pending request queue
  */
-Queue.prototype._dequeuePendingRequest = function(item) {
+Queue.prototype._dequeuePendingRequest = function (item) {
   var idx = this.pendingRequests.indexOf(item);
   if (idx !== -1) {
     this.pendingRequests.splice(idx, 1);
@@ -238,7 +281,7 @@ Queue.prototype._dequeuePendingRequest = function(item) {
   }
 };
 
-Queue.prototype._maybeLog = function(data, originalError) {
+Queue.prototype._maybeLog = function (data, originalError) {
   if (this.logger && this.options.verbose) {
     var message = originalError;
     message = message || _.get(data, 'body.trace.exception.message');
@@ -254,8 +297,12 @@ Queue.prototype._maybeLog = function(data, originalError) {
   }
 };
 
-Queue.prototype._maybeCallWait = function() {
-  if (_.isFunction(this.waitCallback) && this.pendingItems.length === 0 && this.pendingRequests.length === 0) {
+Queue.prototype._maybeCallWait = function () {
+  if (
+    _.isFunction(this.waitCallback) &&
+    this.pendingItems.length === 0 &&
+    this.pendingRequests.length === 0
+  ) {
     if (this.waitIntervalID) {
       this.waitIntervalID = clearInterval(this.waitIntervalID);
     }
@@ -265,4 +312,50 @@ Queue.prototype._maybeCallWait = function() {
   return false;
 };
 
+/**
+ * Handles the API response for an item with a replay ID.
+ * Based on the success or failure status of the response,
+ * it either sends or discards the associated session replay.
+ *
+ * @param {string} replayId - The ID of the replay to handle
+ * @param {Object} response - The API response
+ * @returns {Promise<boolean>} A promise that resolves to true if replay was sent successfully,
+ *                             false if replay was discarded or an error occurred
+ * @private
+ */
+Queue.prototype._handleReplayResponse = async function (replayId, response, headers) {
+  if (!this.replayMap) {
+    console.warn('Queue._handleReplayResponse: ReplayMap not available');
+    return false;
+  }
+
+  if (!replayId) {
+    console.warn('Queue._handleReplayResponse: No replayId provided');
+    return false;
+  }
+
+  try {
+    if (this._shouldSendReplay(response, headers)) {
+      return await this.replayMap.send(replayId);
+    } else {
+      this.replayMap.discard(replayId);
+      return false;
+    }
+  } catch (error) {
+    console.error('Error handling replay response:', error);
+    return false;
+  }
+};
+
+Queue.prototype._shouldSendReplay = function (response, headers) {
+  if (response?.err !== 0 ||
+      !headers ||
+      headers['Rollbar-Replay-Enabled'] !== 'true' ||
+      headers['Rollbar-Replay-RateLimit-Remaining'] === '0') {
+    return false;
+  }
+
+  return true;
+};
+
 module.exports = Queue;