Enable depth of traversal for node local vars (#914)

* feat: enable depth of traversal for node local vars

* fix: style fixes

Author: waltjones

src/server/locals.js

@@ -1,13 +1,28 @@
 /* globals Map */
 var inspector = require('inspector');
 var async = require('async');
+var _ = require('../utility');
+
+// It's helpful to have default limits, as the data expands quickly in real environments.
+// depth = 1 is  enough to capture the members of top level objects and arrays.
+// maxProperties limits the number of properties captured from non-array objects.
+// When this value is too small, relevant values for debugging are easily omitted.
+// maxArray applies to array objects, which in practice may be arbitrarily large,
+// yet for debugging we usually only care about the pattern of data that is established,
+// so a smaller limit is usually sufficient.
+var DEFAULT_OPTIONS = {
+  depth: 1,
+  maxProperties: 30,
+  maxArray: 5
+}
 
-function Locals(config) {
+function Locals(options) {
   if (!(this instanceof Locals)) {
-    return new Locals(config);
+    return new Locals(options);
   }
 
-  this.config = config;
+  options = _.isType(options, 'object') ? options : {};
+  this.options = _.merge(DEFAULT_OPTIONS, options);
 
   this.initSession();
 }
@@ -62,7 +77,7 @@ Locals.prototype.mergeLocals = function(localsMap, stack, key, callback) {
     return callback(e);
   }
 
-  getLocalScopesForFrames(matchedFrames, callback);
+  getLocalScopesForFrames(matchedFrames, this.options, callback);
 }
 
 // Finds frames in localParams that match file and line locations in stack.
@@ -115,11 +130,12 @@ function matchedFrame(callFrame, stackLocation) {
     callFrameColumn === position.column;
 }
 
-function getLocalScopesForFrames(matchedFrames, callback) {
-  async.each(matchedFrames, getLocalScopeForFrame, callback);
+function getLocalScopesForFrames(matchedFrames, 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');
@@ -135,35 +151,102 @@ function getLocalScopeForFrame(matchedFrame, callback) {
 
     var locals = response.result;
     matchedFrame.stackLocation.locals = {};
-    for (var local of locals) {
-      matchedFrame.stackLocation.locals[local.name] = getLocalValue(local);
+    var localsContext = {
+      localsObject: matchedFrame.stackLocation.locals,
+      options: options,
+      depth: options.depth
     }
-
-    callback(null);
+    async.each(locals, getLocalValue.bind(localsContext), callback);
   });
 }
 
-function getLocalValue(local) {
-  var value;
+function getLocalValue(local, callback) {
+  var localsObject = this.localsObject;
+  var options = this.options;
+  var depth = this.depth;
+
+  function cb(error, value) {
+    if (error) {
+      // Add the relevant data to the error object,
+      // taking care to preserve the innermost data context.
+      if (!error.rollbarContext) {
+        error.rollbarContext = local;
+      }
+      return callback(error);
+    }
 
-  switch (local.value.type) {
-    case 'undefined': value = 'undefined'; break;
-    case 'object': value = getObjectValue(local); break;
-    case 'array': value = getObjectValue(local); break;
-    default: value = local.value.value; break;
+    if (_.typeName(localsObject) === 'array') {
+      localsObject.push(value);
+    } else {
+      localsObject[local.name] = value;
+    }
+    callback(null);
   }
 
-  return value;
+  if (!local.value) {
+    return cb(null, '[unavailable]');
+  }
+
+  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;
+  }
 }
 
-function getObjectValue(local) {
+function getObjectType(local) {
   if (local.value.className) {
-    return '<' + local.value.className + ' object>'
+    return '<' + local.value.className + ' object>';
   } else {
-    return '<object>'
+    return '<object>';
   }
 }
 
+function getSymbolValue(local) {
+  return local.value.description;
+}
+
+function getObjectValue(local, options, depth, callback) {
+  if (!local.value.objectId) {
+    if ('value' in local.value) {
+      // Treat as immediate value. (Known example is `null`.)
+      return callback(null, local.value.value);
+    }
+  }
+
+  if (depth === 0) {
+    return callback(null, getObjectType(local));
+  }
+
+  getProperties(local.value.objectId, function(err, response){
+    if (err) {
+      return callback(err);
+    }
+
+    var isArray = local.value.className === 'Array';
+    var length = isArray ? options.maxArray : options.maxProperties;
+    var properties = response.result.slice(0, length);
+    var localsContext = {
+      localsObject: isArray ? [] : {},
+      options: options,
+      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){
+      if (error) {
+        return callback(error);
+      }
+
+      callback(null, localsContext.localsObject);
+    });
+  });
+}
+
 function getProperties(objectId, callback) {
   Locals.session.post('Runtime.getProperties', { objectId : objectId, ownProperties: true }, callback);
 }

src/server/parser.js

@@ -314,7 +314,9 @@ exports.parseException = function (exc, options, item, callback) {
       item.notifier.locals.mergeLocals(item.localsMap, stack, exc.stack, function (err) {
         if (err) {
           logger.error('could not parse locals, err: ' + err);
-          return callback(err);
+
+          // Don't reject the occurrence, record the error instead.
+          item.diagnostic['error parsing locals'] = err;
         }
 
         return callback(null, ret);

src/server/rollbar.js

@@ -41,11 +41,11 @@ function Rollbar(options, client) {
   var api = new API(this.options, transport, urllib, truncation, jsonBackup);
   var telemeter = new Telemeter(this.options)
   this.client = client || new Client(this.options, api, logger, telemeter, 'server');
-  if (options.locals) {
+  if (this.options.locals) {
     // Capturing stack local variables is only supported in Node 10 and higher.
     var nodeMajorVersion = process.versions.node.split('.')[0];
     if (nodeMajorVersion >= 10) {
-      this.locals = new Locals(this.options)
+      this.locals = new Locals(this.options.locals);
     }
   }
   addTransformsToNotifier(this.client.notifier);

test/fixtures/locals.fixtures.js

@@ -314,7 +314,7 @@ var localsFixtures = {
         type: 'object',
         className: 'FooClass',
         description: 'FooClass',
-        objectId: '{"injectedScriptId":1,"id":48}'
+        objectId: 'nestedProps1'
       },
       writable: true,
       configurable: true,
@@ -327,7 +327,7 @@ var localsFixtures = {
         type: 'object',
         className: 'BarClass',
         description: 'BarClass',
-        objectId: '{"injectedScriptId":1,"id":48}'
+        objectId: 'nestedProps2'
       },
       writable: true,
       configurable: true,
@@ -370,7 +370,7 @@ var localsFixtures = {
     array1: {
       name: 'args',
       value: {
-        type: 'array',
+        type: 'object',
         subtype: 'array',
         className: 'Array',
         description: 'Array(1)',
@@ -380,6 +380,43 @@ var localsFixtures = {
       configurable: true,
       enumerable: true,
       isOwn: true
+    },
+    function1: {
+      name: 'func',
+      value: {
+        type: 'function',
+        className: 'Function',
+        description: 'Array(1)',
+        objectId: '{"injectedScriptId":1,"id":64}'
+      },
+      writable: true,
+      configurable: true,
+      enumerable: true,
+      isOwn: true
+    },
+    function2: {
+      name: 'asyncFunc',
+      value: {
+        type: 'function',
+        className: 'AsyncFunction',
+        objectId: '{"injectedScriptId":1,"id":32}'
+      },
+      writable: true,
+      configurable: true,
+      enumerable: true,
+      isOwn: true
+    },
+    null1: {
+      name: 'parent',
+      value: {
+        subtype: 'null',
+        type: 'object',
+        value: null
+      },
+      configurable: true,
+      writable: true,
+      enumerable: true,
+      isOwn: true
     }
   }
 }