rollbar 2.26.3 → 3.0.0-alpha.1

package/src/rollbar.js

@@ -1,7 +1,7 @@
-var RateLimiter = require('./rateLimiter');
-var Queue = require('./queue');
-var Notifier = require('./notifier');
-var _ = require('./utility');
+const RateLimiter = require('./rateLimiter');
+const Queue = require('./queue');
+const Notifier = require('./notifier');
+const _ = require('./utility');
 
 /*
  * Rollbar - the interface to Rollbar
@@ -10,14 +10,17 @@ var _ = require('./utility');
  * @param api
  * @param logger
  */
-function Rollbar(options, api, logger, telemeter, platform) {
+function Rollbar(options, api, logger, telemeter, tracing, replayMap, platform) {
   this.options = _.merge(options);
   this.logger = logger;
   Rollbar.rateLimiter.configureGlobal(this.options);
   Rollbar.rateLimiter.setPlatformOptions(platform, this.options);
   this.api = api;
-  this.queue = new Queue(Rollbar.rateLimiter, api, logger, this.options);
+  this.queue = new Queue(Rollbar.rateLimiter, api, logger, this.options, replayMap);
 
+  this.tracing = tracing;
+
+  // Legacy OpenTracing support
   // This must happen before the Notifier is created
   var tracer = this.options.tracer || null;
   if (validateTracer(tracer)) {
@@ -38,7 +41,7 @@ function Rollbar(options, api, logger, telemeter, platform) {
 
 var defaultOptions = {
   maxItems: 0,
-  itemsPerMinute: 60
+  itemsPerMinute: 60,
 };
 
 Rollbar.rateLimiter = new RateLimiter(defaultOptions);
@@ -57,6 +60,7 @@ Rollbar.prototype.configure = function (options, payloadData) {
 
   this.options = _.merge(oldOptions, options, payload);
 
+  // Legacy OpenTracing support
   // This must happen before the Notifier is configured
   var tracer = this.options.tracer || null;
   if (validateTracer(tracer)) {
@@ -74,7 +78,7 @@ Rollbar.prototype.configure = function (options, payloadData) {
   this.global(this.options);
 
   if (validateTracer(options.tracer)) {
-    this.tracer = options.tracer
+    this.tracer = options.tracer;
   }
 
   return this;
@@ -150,10 +154,25 @@ Rollbar.prototype._log = function (defaultLevel, item) {
     return;
   }
   try {
-    this._addTracingInfo(item);
     item.level = item.level || defaultLevel;
-    this.telemeter && this.telemeter._captureRollbarItem(item);
-    item.telemetryEvents = (this.telemeter && this.telemeter.copyEvents()) || [];
+
+    const replayId = this._replayIdIfTriggered(item);
+    this._addTracingAttributes(item, replayId);
+
+    // Legacy OpenTracing support
+    this._addTracingInfo(item);
+
+    const telemeter = this.telemeter;
+    if (telemeter) {
+      telemeter._captureRollbarItem(item);
+      item.telemetryEvents = telemeter.copyEvents() || [];
+
+      if (telemeter.telemetrySpan) {
+        telemeter.telemetrySpan.end({'rollbar.replay.id': replayId});
+        telemeter.telemetrySpan = telemeter.tracing.startSpan('rollbar-telemetry', {});
+      }
+    }
+
     this.notifier.log(item, callback);
   } catch (e) {
     if (callback) {
@@ -163,6 +182,30 @@ Rollbar.prototype._log = function (defaultLevel, item) {
   }
 };
 
+Rollbar.prototype._addTracingAttributes = function (item, replayId) {
+  const span = this.tracing?.getSpan();
+
+  const attributes = [
+    {key: 'replay_id', value: replayId},
+    {key: 'session_id', value: this.tracing?.sessionId},
+    {key: 'span_id', value: span?.spanId},
+    {key: 'trace_id', value: span?.traceId},
+  ];
+  _.addItemAttributes(item.data, attributes);
+
+  span?.addEvent(
+    'rollbar.occurrence',
+    [{key: 'rollbar.occurrence.uuid', value: item.uuid}],
+  );
+};
+
+Rollbar.prototype._replayIdIfTriggered = function (item) {
+  const levels = this.options.recorder?.triggerOptions?.item?.levels || [];
+  if (levels.includes(item.level)) {
+    return this.tracing?.idGen(8);
+  }
+}
+
 Rollbar.prototype._defaultLogLevel = function () {
   return this.options.logLevel || 'debug';
 };
@@ -191,8 +234,14 @@ Rollbar.prototype._addTracingInfo = function (item) {
       span.setTag('rollbar.error_uuid', item.uuid);
       span.setTag('rollbar.has_error', true);
       span.setTag('error', true);
-      span.setTag('rollbar.item_url', `https://rollbar.com/item/uuid/?uuid=${item.uuid}`);
-      span.setTag('rollbar.occurrence_url', `https://rollbar.com/occurrence/uuid/?uuid=${item.uuid}`);
+      span.setTag(
+        'rollbar.item_url',
+        `https://rollbar.com/item/uuid/?uuid=${item.uuid}`,
+      );
+      span.setTag(
+        'rollbar.occurrence_url',
+        `https://rollbar.com/occurrence/uuid/?uuid=${item.uuid}`,
+      );
 
       // add span ID & trace ID to occurrence
       var opentracingSpanId = span.context().toSpanId();
@@ -204,12 +253,12 @@ Rollbar.prototype._addTracingInfo = function (item) {
       } else {
         item.custom = {
           opentracing_span_id: opentracingSpanId,
-          opentracing_trace_id: opentracingTraceId
+          opentracing_trace_id: opentracingTraceId,
         };
       }
     }
   }
-}
+};
 
 function generateItemHash(item) {
   var message = item.message || '';
@@ -260,12 +309,14 @@ function validateSpan(span) {
 
   var spanContext = span.context();
 
-  if (!spanContext
-    || !spanContext.toSpanId
-    || !spanContext.toTraceId
-    || typeof spanContext.toSpanId !== 'function'
-    || typeof spanContext.toTraceId !== 'function') {
-    return false
+  if (
+    !spanContext ||
+    !spanContext.toSpanId ||
+    !spanContext.toTraceId ||
+    typeof spanContext.toSpanId !== 'function' ||
+    typeof spanContext.toTraceId !== 'function'
+  ) {
+    return false;
   }
 
   return true;

package/src/scrub.js

@@ -79,7 +79,6 @@ function _getScrubFieldRegexs(scrubFields) {
   return ret;
 }
 
-
 function _getScrubQueryParamRegexs(scrubFields) {
   var ret = [];
   var pat;

package/src/server/locals.js

@@ -15,8 +15,8 @@ var DEFAULT_OPTIONS = {
   uncaughtOnly: true,
   depth: 1,
   maxProperties: 30,
-  maxArray: 5
-}
+  maxArray: 5,
+};
 
 function Locals(options, logger) {
   if (!(this instanceof Locals)) {
@@ -31,7 +31,7 @@ function Locals(options, logger) {
   this.initSession();
 }
 
-Locals.prototype.initSession = function() {
+Locals.prototype.initSession = function () {
   if (Locals.session) {
     this.disconnectSession();
   }
@@ -62,33 +62,39 @@ Locals.prototype.initSession = function() {
     self.initialized = true;
     updatePauseState(self.options, self.logger);
   });
-}
+};
 
-Locals.prototype.disconnectSession = function() {
+Locals.prototype.disconnectSession = function () {
   if (Locals.session) {
     updatePauseState({ enabled: false }, this.logger);
     Locals.session.disconnect();
     Locals.session = null;
   }
-}
+};
 
-Locals.prototype.updateOptions = function(options) {
-  var pauseStateChanged = this.options.enabled != options.enabled || this.options.uncaughtOnly != options.uncaughtOnly;
+Locals.prototype.updateOptions = function (options) {
+  var pauseStateChanged =
+    this.options.enabled != options.enabled ||
+    this.options.uncaughtOnly != options.uncaughtOnly;
 
   this.options = _.merge(this.options, options);
 
   if (this.initialized && pauseStateChanged) {
     updatePauseState(this.options, this.logger);
   }
-}
+};
 
 function updatePauseState(options, logger) {
   var state = pauseStateFromOptions(options);
-  Locals.session.post('Debugger.setPauseOnExceptions', { state: state}, (err, _result) => {
-    if (err) {
-      logger.error('error in setPauseOnExceptions', err);
-    }
-  });
+  Locals.session.post(
+    'Debugger.setPauseOnExceptions',
+    { state: state },
+    (err, _result) => {
+      if (err) {
+        logger.error('error in setPauseOnExceptions', err);
+      }
+    },
+  );
 }
 
 function pauseStateFromOptions(options) {
@@ -103,11 +109,11 @@ function pauseStateFromOptions(options) {
   }
 }
 
-Locals.prototype.currentLocalsMap = function() {
+Locals.prototype.currentLocalsMap = function () {
   return new Map(Locals.currentErrors);
-}
+};
 
-Locals.prototype.mergeLocals = function(localsMap, stack, key, callback) {
+Locals.prototype.mergeLocals = function (localsMap, stack, key, callback) {
   var matchedFrames;
 
   try {
@@ -124,22 +130,26 @@ Locals.prototype.mergeLocals = function(localsMap, stack, key, callback) {
   }
 
   getLocalScopesForFrames(matchedFrames, this.options, callback);
-}
+};
 
 // Finds frames in localParams that match file and line locations in stack.
 function matchFrames(localParams, stack) {
   var matchedFrames = [];
-  var localIndex = 0, stackIndex = 0;
+  var localIndex = 0,
+    stackIndex = 0;
   var stackLength = stack.length;
   var callFrames = localParams.callFrames;
   var callFramesLength = callFrames.length;
 
   for (; stackIndex < stackLength; stackIndex++) {
     while (localIndex < callFramesLength) {
-      if (firstFrame(localIndex, stackIndex) || matchedFrame(callFrames[localIndex], stack[stackIndex])) {
+      if (
+        firstFrame(localIndex, stackIndex) ||
+        matchedFrame(callFrames[localIndex], stack[stackIndex])
+      ) {
         matchedFrames.push({
           stackLocation: stack[stackIndex],
-          callFrame: callFrames[localIndex]
+          callFrame: callFrames[localIndex],
         });
         localIndex++;
         break;
@@ -165,32 +175,38 @@ function matchedFrame(callFrame, stackLocation) {
 
   // Node.js prefixes filename some URLs with 'file:///' in Debugger.callFrame,
   // but with only '/' in the error.stack string. Remove the prefix to facilitate a match.
-  var callFrameUrl = callFrame.url.replace(/file:\/\//,'');
+  var callFrameUrl = callFrame.url.replace(/file:\/\//, '');
 
   // lineNumber is zero indexed, so offset it.
   var callFrameLine = callFrame.location.lineNumber + 1;
   var callFrameColumn = callFrame.location.columnNumber;
 
-  return callFrameUrl === position.source &&
+  return (
+    callFrameUrl === position.source &&
     callFrameLine === position.line &&
-    callFrameColumn === position.column;
+    callFrameColumn === position.column
+  );
 }
 
 function getLocalScopesForFrames(matchedFrames, options, callback) {
-  async.each(matchedFrames, getLocalScopeForFrame.bind({ options: options }), callback);
+  async.each(
+    matchedFrames,
+    getLocalScopeForFrame.bind({ options: options }),
+    callback,
+  );
 }
 
 function getLocalScopeForFrame(matchedFrame, callback) {
   var options = this.options;
   var scopes = matchedFrame.callFrame.scopeChain;
 
-  var scope = scopes.find(scope => scope.type === 'local');
+  var scope = scopes.find((scope) => scope.type === 'local');
 
   if (!scope) {
     return callback(null); // Do nothing return success.
   }
 
-  getProperties(scope.object.objectId, function(err, response){
+  getProperties(scope.object.objectId, function (err, response) {
     if (err) {
       return callback(err);
     }
@@ -200,8 +216,8 @@ function getLocalScopeForFrame(matchedFrame, callback) {
     var localsContext = {
       localsObject: matchedFrame.stackLocation.locals,
       options: options,
-      depth: options.depth
-    }
+      depth: options.depth,
+    };
     async.each(locals, getLocalValue.bind(localsContext), callback);
   });
 }
@@ -234,11 +250,21 @@ function getLocalValue(local, callback) {
   }
 
   switch (local.value.type) {
-    case 'undefined': cb(null, 'undefined'); break;
-    case 'object': getObjectValue(local, options, depth, cb); break;
-    case 'function': cb(null, getObjectType(local)); break;
-    case 'symbol': cb(null, getSymbolValue(local)); break;
-    default: cb(null, local.value.value); break;
+    case 'undefined':
+      cb(null, 'undefined');
+      break;
+    case 'object':
+      getObjectValue(local, options, depth, cb);
+      break;
+    case 'function':
+      cb(null, getObjectType(local));
+      break;
+    case 'symbol':
+      cb(null, getSymbolValue(local));
+      break;
+    default:
+      cb(null, local.value.value);
+      break;
   }
 }
 
@@ -266,7 +292,7 @@ function getObjectValue(local, options, depth, callback) {
     return callback(null, getObjectType(local));
   }
 
-  getProperties(local.value.objectId, function(err, response){
+  getProperties(local.value.objectId, function (err, response) {
     if (err) {
       return callback(err);
     }
@@ -277,13 +303,13 @@ function getObjectValue(local, options, depth, callback) {
     var localsContext = {
       localsObject: isArray ? [] : {},
       options: options,
-      depth: depth - 1
-    }
+      depth: depth - 1,
+    };
 
     // For arrays, use eachSeries to ensure order is preserved.
     // Otherwise, use each for faster completion.
     var iterator = isArray ? async.eachSeries : async.each;
-    iterator(properties, getLocalValue.bind(localsContext), function(error){
+    iterator(properties, getLocalValue.bind(localsContext), function (error) {
       if (error) {
         return callback(error);
       }
@@ -294,7 +320,11 @@ function getObjectValue(local, options, depth, callback) {
 }
 
 function getProperties(objectId, callback) {
-  Locals.session.post('Runtime.getProperties', { objectId : objectId, ownProperties: true }, callback);
+  Locals.session.post(
+    'Runtime.getProperties',
+    { objectId: objectId, ownProperties: true },
+    callback,
+  );
 }
 
 module.exports = Locals;

package/src/server/logger.js

@@ -4,20 +4,20 @@ var verbose = true;
 
 var logger = {
   /* eslint-disable no-console */
-  log: function() {
+  log: function () {
     if (verbose) {
       console.log.apply(console, arguments);
     }
   },
-  error: function() {
+  error: function () {
     if (verbose) {
       console.error.apply(console, arguments);
     }
   },
   /* eslint-enable no-console */
-  setVerbose: function(val) {
+  setVerbose: function (val) {
     verbose = val;
-  }
+  },
 };
 
 module.exports = logger;

package/src/server/parser.js

@@ -14,19 +14,16 @@ var tracePattern =
 var jadeTracePattern = /^\s*at .+ \(.+ (at[^)]+\))\)$/;
 var jadeFramePattern = /^\s*(>?) [0-9]+\|(\s*.+)$/m;
 
-
-var cache = new lru({max: 100});
+var cache = new lru({ max: 100 });
 var pendingReads = {};
 
 exports.cache = cache;
 exports.pendingReads = pendingReads;
 
-
 /*
  * Internal
  */
 
-
 function getMultipleErrors(errors) {
   var errArray, key;
 
@@ -52,10 +49,19 @@ function getMultipleErrors(errors) {
   return errArray;
 }
 
-
 function parseJadeDebugFrame(body) {
-  var lines, lineNumSep, filename, lineno, numLines, msg, i,
-    contextLine, preContext, postContext, line, jadeMatch;
+  var lines,
+    lineNumSep,
+    filename,
+    lineno,
+    numLines,
+    msg,
+    i,
+    contextLine,
+    preContext,
+    postContext,
+    line,
+    jadeMatch;
 
   // Given a Jade exception body, return a frame object
   lines = body.split('\n');
@@ -90,7 +96,10 @@ function parseJadeDebugFrame(body) {
   }
 
   preContext = preContext.slice(0, Math.min(preContext.length, linesOfContext));
-  postContext = postContext.slice(0, Math.min(postContext.length, linesOfContext));
+  postContext = postContext.slice(
+    0,
+    Math.min(postContext.length, linesOfContext),
+  );
 
   return {
     frame: {
@@ -100,29 +109,32 @@ function parseJadeDebugFrame(body) {
       code: contextLine,
       context: {
         pre: preContext,
-        post: postContext
-      }
+        post: postContext,
+      },
     },
-    message: msg
+    message: msg,
   };
 }
 
-
 function extractContextLines(frame, fileLines) {
   frame.code = fileLines[frame.lineno - 1];
   frame.context = {
-    pre: fileLines.slice(Math.max(0, frame.lineno - (linesOfContext + 1)), frame.lineno - 1),
-    post: fileLines.slice(frame.lineno, frame.lineno + linesOfContext)
+    pre: fileLines.slice(
+      Math.max(0, frame.lineno - (linesOfContext + 1)),
+      frame.lineno - 1,
+    ),
+    post: fileLines.slice(frame.lineno, frame.lineno + linesOfContext),
   };
 }
 
 function mapPosition(position, diagnostic) {
-  return stackTrace.mapSourcePosition({
+  return stackTrace.mapSourcePosition(
+    {
       source: position.source,
       line: position.line,
-      column: position.column
+      column: position.column,
     },
-    diagnostic
+    diagnostic,
   );
 }
 
@@ -144,7 +156,7 @@ function parseFrameLine(line, callback) {
   var runtimePosition = {
     source: data[1],
     line: Math.floor(data[2]),
-    column: Math.floor(data[3]) - 1
+    column: Math.floor(data[3]) - 1,
   };
   if (this.useSourceMaps) {
     position = mapPosition(runtimePosition, this.diagnostic);
@@ -157,7 +169,7 @@ function parseFrameLine(line, callback) {
     filename: position.source,
     lineno: position.line,
     colno: position.column,
-    runtimePosition: runtimePosition // Used to match frames for locals
+    runtimePosition: runtimePosition, // Used to match frames for locals
   };
 
   // For coffeescript, lineno and colno refer to the .coffee positions
@@ -173,7 +185,6 @@ function parseFrameLine(line, callback) {
   callback(null, frame);
 }
 
-
 function shouldReadFrameFile(frameFilename, callback) {
   var isValidFilename, isCached, isPending;
 
@@ -184,7 +195,6 @@ function shouldReadFrameFile(frameFilename, callback) {
   callback(null, isValidFilename && !isCached && !isPending);
 }
 
-
 function readFileLines(filename, callback) {
   try {
     fs.readFile(filename, function (err, fileData) {
@@ -210,7 +220,6 @@ function checkFileExists(filename, callback) {
   });
 }
 
-
 function gatherContexts(frames, callback) {
   var frameFilenames = [];
 
@@ -280,7 +289,6 @@ function gatherContexts(frames, callback) {
         });
       });
     });
-
   });
 }
 
@@ -288,7 +296,6 @@ function gatherContexts(frames, callback) {
  * Public API
  */
 
-
 exports.parseException = function (exc, options, item, callback) {
   var multipleErrs = getMultipleErrors(exc.errors);
 
@@ -299,13 +306,13 @@ exports.parseException = function (exc, options, item, callback) {
       logger.error('could not parse exception, err: ' + err);
       return callback(err);
     }
-    message = String(exc.message || '<no message>') ;
+    message = String(exc.message || '<no message>');
     clss = String(exc.name || '<unknown>');
 
     ret = {
       class: clss,
       message: message,
-      frames: stack
+      frames: stack,
     };
 
     if (multipleErrs && multipleErrs.length) {
@@ -313,7 +320,7 @@ exports.parseException = function (exc, options, item, callback) {
       ret = {
         class: clss,
         message: String(firstErr.message || '<no message>'),
-        frames: stack
+        frames: stack,
       };
     }
 
@@ -325,25 +332,30 @@ exports.parseException = function (exc, options, item, callback) {
     }
 
     if (item.localsMap) {
-      item.notifier.locals.mergeLocals(item.localsMap, stack, exc.stack, function (err) {
-        if (err) {
-          logger.error('could not parse locals, err: ' + err);
+      item.notifier.locals.mergeLocals(
+        item.localsMap,
+        stack,
+        exc.stack,
+        function (err) {
+          if (err) {
+            logger.error('could not parse locals, err: ' + err);
 
-          // Don't reject the occurrence, record the error instead.
-          item.diagnostic['error parsing locals'] = err;
-        }
+            // Don't reject the occurrence, record the error instead.
+            item.diagnostic['error parsing locals'] = err;
+          }
 
-        return callback(null, ret);
-      });
+          return callback(null, ret);
+        },
+      );
     } else {
       return callback(null, ret);
     }
   });
 };
 
-
 exports.parseStack = function (stack, options, item, callback) {
-  var lines, _stack = stack;
+  var lines,
+    _stack = stack;
 
   // Some JS frameworks (e.g. Meteor) might bury the stack property
   while (typeof _stack === 'object') {
@@ -359,14 +371,27 @@ exports.parseStack = function (stack, options, item, callback) {
   }
 
   // Parse out all of the frame and filename info
-  async.map(lines, parseFrameLine.bind({ useSourceMaps: options.nodeSourceMaps, diagnostic: item.diagnostic }), function (err, frames) {
-    if (err) {
-      return callback(err);
-    }
-    frames.reverse();
-    async.filter(frames, function (frame, callback) { callback(null, !!frame); }, function (err, results) {
-      if (err) return callback(err);
-      gatherContexts(results, callback);
-    });
-  });
+  async.map(
+    lines,
+    parseFrameLine.bind({
+      useSourceMaps: options.nodeSourceMaps,
+      diagnostic: item.diagnostic,
+    }),
+    function (err, frames) {
+      if (err) {
+        return callback(err);
+      }
+      frames.reverse();
+      async.filter(
+        frames,
+        function (frame, callback) {
+          callback(null, !!frame);
+        },
+        function (err, results) {
+          if (err) return callback(err);
+          gatherContexts(results, callback);
+        },
+      );
+    },
+  );
 };