rollbar 2.26.2 → 2.26.4

package/test/server.locals.test.js

@@ -13,7 +13,7 @@ var localsFixtures = require('./fixtures/locals.fixtures');
 var nodeMajorVersion = process.versions.node.split('.')[0];
 
 async function wait(ms) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
@@ -50,7 +50,7 @@ async function nodeThrowAndCatch(rollbar, callback) {
 
 function nestedError(nestedMessage, _password) {
   var nestedError = new Error(nestedMessage);
-  throw(nestedError);
+  throw nestedError;
 }
 
 async function nodeThrowNested(rollbar, callback) {
@@ -61,7 +61,7 @@ async function nodeThrowNested(rollbar, callback) {
 
     try {
       var newMessage = 'nested ' + message;
-      nestedError(newMessage, password)
+      nestedError(newMessage, password);
     } catch (e) {
       err.nested = e;
     }
@@ -86,13 +86,12 @@ function fakeSessionPostHandler(responses) {
     setTimeout(function () {
       callback(error, response);
     }, 1);
-  }
+  };
 }
 
-
 async function nodeThrowWithNestedLocals(rollbar, callback) {
   setTimeout(function () {
-    var arr = [{ zero: [0, 0]}, { one: 1}, { two: 2}, { three: 3}];
+    var arr = [{ zero: [0, 0] }, { one: 1 }, { two: 2 }, { three: 3 }];
     var obj = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e', f: 'f' };
     var password = 'password';
     var sym = Symbol('foo');
@@ -107,7 +106,7 @@ function recurse(curr, limit) {
   if (curr < limit) {
     recurse(curr + 1, limit);
   } else {
-    throw new Error('deep stack error, limit='+limit);
+    throw new Error('deep stack error, limit=' + limit);
   }
 }
 
@@ -131,16 +130,30 @@ function verifyThrownError(r) {
   assert.isTrue(addItemStub.called);
   var data = addItemStub.getCall(0).args[3].data;
   assert.equal(data.body.trace_chain[0].exception.message, 'node error');
-  if (nodeMajorVersion >= 10) {
-    // Node 10+; locals enabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals.error, '<Error object>');
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals.timer, '<Timeout object>');
+  var length = data.body.trace_chain[0].frames.length;
+  assert.ok(length > 1);
+
+  if (nodeMajorVersion >= 18) {
+    // Node >=18; locals only in top frame
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.error,
+      '<Error object>',
+    );
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
+  } else if (nodeMajorVersion >= 10) {
+    // Node >=10; locals enabled
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.error,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 2].locals.timer,
+      '<Timeout object>',
+    );
   } else {
-    // Node 8; locals disabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals, undefined);
+    // Node <=8; locals disabled
+    assert.equal(data.body.trace_chain[0].frames[length - 1].locals, undefined);
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
   }
   addItemStub.restore();
 }
@@ -151,15 +164,29 @@ function verifyCaughtError(r) {
   assert.isTrue(addItemStub.called);
   var data = addItemStub.getCall(0).args[3].data;
   assert.equal(data.body.trace_chain[0].exception.message, 'caught error');
-  if (nodeMajorVersion >= 10) {
-    // Node 10+; locals enabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals.error, '<Error object>');
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals.timer, '<Timeout object>');
+  var length = data.body.trace_chain[0].frames.length;
+  assert.ok(length > 1);
+
+  if (nodeMajorVersion >= 18) {
+    // Node >=18; locals only in top frame
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.error,
+      '<Error object>',
+    );
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
+  } else if (nodeMajorVersion >= 10) {
+    // Node 10..<18; locals enabled
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.error,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 2].locals.timer,
+      '<Timeout object>',
+    );
   } else {
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals, undefined);
+    assert.equal(data.body.trace_chain[0].frames[length - 1].locals, undefined);
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
   }
   addItemStub.restore();
 }
@@ -171,25 +198,86 @@ function verifyNestedError(r) {
   var data = addItemStub.getCall(0).args[3].data;
   assert.equal(data.body.trace_chain[0].exception.message, 'test error');
   assert.equal(data.body.trace_chain[1].exception.message, 'nested test error');
-  if (nodeMajorVersion >= 10) {
-    // Node 10+; locals enabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals.err, '<Error object>');
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals.timer, '<Timeout object>');
+  var length = data.body.trace_chain[0].frames.length;
+  assert.ok(length > 1);
+
+  if (nodeMajorVersion >= 18) {
+    // Node >=18; locals only in top frame
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.message,
+      'test error',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.password,
+      '********',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.err,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.newMessage,
+      'nested test error',
+    );
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
 
     length = data.body.trace_chain[1].frames.length;
-    assert.equal(data.body.trace_chain[1].frames[length-1].locals.nestedMessage, 'nested test error');
-    assert.equal(data.body.trace_chain[1].frames[length-1].locals.nestedError, '<Error object>');
-    assert.equal(data.body.trace_chain[1].frames[length-2].locals.message, 'test error');
-    assert.equal(data.body.trace_chain[1].frames[length-2].locals.password, '********');
-    assert.equal(data.body.trace_chain[1].frames[length-2].locals.err, '<Error object>');
-    assert.equal(data.body.trace_chain[1].frames[length-2].locals.newMessage, 'nested test error');
+    assert.ok(length > 1);
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 1].locals.nestedMessage,
+      'nested test error',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 1].locals._password,
+      '123456',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 1].locals.nestedError,
+      '<Error object>',
+    );
+    assert.equal(data.body.trace_chain[1].frames[length - 2].locals, undefined);
+  } else if (nodeMajorVersion >= 10) {
+    // Node >=10; locals enabled
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.err,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 2].locals.timer,
+      '<Timeout object>',
+    );
+
+    length = data.body.trace_chain[1].frames.length;
+    assert.ok(length > 1);
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 1].locals.nestedMessage,
+      'nested test error',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 1].locals.nestedError,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 2].locals.message,
+      'test error',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 2].locals.password,
+      '********',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 2].locals.err,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[1].frames[length - 2].locals.newMessage,
+      'nested test error',
+    );
   } else {
-    // Node 8; locals disabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals, undefined);
-}
+    // Node <=8; locals disabled
+    assert.equal(data.body.trace_chain[0].frames[length - 1].locals, undefined);
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
+  }
   addItemStub.restore();
 }
 
@@ -199,19 +287,47 @@ function verifyRejectedPromise(r) {
   assert.isTrue(addItemStub.called);
   var data = addItemStub.getCall(0).args[3].data;
   assert.equal(data.body.trace_chain[0].exception.message, 'promise reject');
-  if (nodeMajorVersion >= 10) {
-    // Node 10+; locals enabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals.error, '<Error object>');
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals.rollbar, '<Rollbar object>');
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals.notifier, '<Notifier object>');
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals.r, '<Rollbar object>');
+  var length = data.body.trace_chain[0].frames.length;
+  assert.ok(length > 1);
+
+  if (nodeMajorVersion >= 18) {
+    // Node >=18; locals only in top frame
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.error,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.callback,
+      '<Function object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.rollbar,
+      '<Rollbar object>',
+    );
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
+  } else if (nodeMajorVersion >= 10) {
+    // Node >=10; locals enabled
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.error,
+      '<Error object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 1].locals.rollbar,
+      '<Rollbar object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 2].locals.notifier,
+      '<Notifier object>',
+    );
+    assert.equal(
+      data.body.trace_chain[0].frames[length - 2].locals.r,
+      '<Rollbar object>',
+    );
   } else {
-    // Node 8; locals disabled
-    var length = data.body.trace_chain[0].frames.length;
-    assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
-    assert.equal(data.body.trace_chain[0].frames[length-2].locals, undefined);
-}
+    // Node <=8; locals disabled
+    assert.equal(data.body.trace_chain[0].frames[length - 1].locals, undefined);
+    assert.equal(data.body.trace_chain[0].frames[length - 2].locals, undefined);
+  }
   addItemStub.restore();
 }
 
@@ -223,276 +339,362 @@ function verifyDefaultOptions(options) {
   assert.equal(options.maxArray, 5);
 }
 
-vows.describe('locals')
+vows
+  .describe('locals')
   .addBatch({
-    'enabled': {
-      topic: function() {
+    enabled: {
+      topic: function () {
         var rollbar = new Rollbar({
           accessToken: 'abc123',
           captureUncaught: true,
           captureUnhandledRejections: true,
-          locals: { module: Locals, uncaughtOnly: true, depth: 0 }
+          locals: { module: Locals, uncaughtOnly: true, depth: 0 },
         });
         var notifier = rollbar.client.notifier;
         rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
         nodeThrow(rollbar, this.callback);
       },
-      'should include locals': function(_err, r) {
+      'should include locals': function (_err, r) {
         verifyThrownError(r);
       },
       'then disabled': {
-        topic: function(_err, r) {
-          r.configure({ locals: { enabled: false }});
+        topic: function (_err, r) {
+          r.configure({ locals: { enabled: false } });
           var notifier = r.client.notifier;
+          assert.ok(notifier);
           r.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           nodeThrowNested(r, this.callback);
         },
-        'should not include locals': function(_err, r) {
+        'should not include locals': function (_err, r) {
           var addItemStub = r.addItemStub;
+          assert.ok(addItemStub);
 
           assert.isTrue(addItemStub.called);
           var data = addItemStub.getCall(0).args[3].data;
-          assert.equal(data.body.trace_chain[0].exception.message, 'test error');
-          assert.equal(data.body.trace_chain[1].exception.message, 'nested test error');
+          assert.equal(
+            data.body.trace_chain[0].exception.message,
+            'test error',
+          );
+          assert.equal(
+            data.body.trace_chain[1].exception.message,
+            'nested test error',
+          );
           var length = data.body.trace_chain[0].frames.length;
-          assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
-          assert.equal(data.body.trace_chain[0].frames[length-2].locals, undefined);
+          assert.ok(length > 1);
+          assert.equal(
+            data.body.trace_chain[0].frames[length - 1].locals,
+            undefined,
+          );
+          assert.equal(
+            data.body.trace_chain[0].frames[length - 2].locals,
+            undefined,
+          );
           addItemStub.restore();
         },
         'then enabled': {
-          topic: function(_err, r) {
-            r.configure({ locals: { enabled: true, uncaughtOnly: false }});
+          topic: function (_err, r) {
+            r.configure({ locals: { enabled: true, uncaughtOnly: false } });
             var notifier = r.client.notifier;
             r.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
             promiseReject(r, this.callback);
           },
-          'should include locals': function(_err, r) {
+          'should include locals': function (_err, r) {
             verifyRejectedPromise(r);
           },
-        }
-      }
-    }
+        },
+      },
+    },
   })
 
   .addBatch({
     'on caught error': {
       'uncaughtOnly: true': {
-        topic: function() {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
             captureUncaught: true,
             captureUnhandledRejections: true,
-            locals: { module: Locals, uncaughtOnly:true, depth: 0 }
+            locals: { module: Locals, uncaughtOnly: true, depth: 0 },
           });
           var notifier = rollbar.client.notifier;
           rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           nodeThrowAndCatch(rollbar, this.callback);
         },
-        'should not include locals': function(_err, r) {
+        'should not include locals': function (_err, r) {
           var addItemStub = r.addItemStub;
 
           assert.isTrue(addItemStub.called);
           var data = addItemStub.getCall(0).args[3].data;
-          assert.equal(data.body.trace_chain[0].exception.message, 'caught error');
+          assert.equal(
+            data.body.trace_chain[0].exception.message,
+            'caught error',
+          );
           var length = data.body.trace_chain[0].frames.length;
-          assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
-          assert.equal(data.body.trace_chain[0].frames[length-2].locals, undefined);
+          assert.ok(length > 1);
+          assert.equal(
+            data.body.trace_chain[0].frames[length - 1].locals,
+            undefined,
+          );
+          assert.equal(
+            data.body.trace_chain[0].frames[length - 2].locals,
+            undefined,
+          );
 
           addItemStub.restore();
         },
         'then uncaughtOnly: false': {
-          topic: function(_err, r) {
-            r.configure({ locals: { uncaughtOnly: false }});
+          topic: function (_err, r) {
+            r.configure({ locals: { uncaughtOnly: false } });
             var notifier = r.client.notifier;
             r.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
             nodeThrowAndCatch(r, this.callback);
           },
-          'should include locals': function(_err, r) {
+          'should include locals': function (_err, r) {
             verifyCaughtError(r);
-          }
-        }
-      }
-    }
+          },
+        },
+      },
+    },
   })
 
   .addBatch({
     'on exception': {
-      'uncaught': {
-        topic: function() {
+      uncaught: {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
             captureUncaught: true,
             captureUnhandledRejections: true,
-            locals: { module: Locals, uncaughtOnly: true, depth: 0 }
+            locals: { module: Locals, uncaughtOnly: true, depth: 0 },
           });
           var notifier = rollbar.client.notifier;
           rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           nodeThrow(rollbar, this.callback);
         },
-        'should include locals': function(_err, r) {
+        'should include locals': function (_err, r) {
           verifyThrownError(r);
-        }
-      }
-    }
+        },
+      },
+    },
   })
 
   .addBatch({
     'on exception': {
-      'nested': {
-        topic: function() {
+      nested: {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
             captureUncaught: true,
-            locals: { module: Locals, uncaughtOnly: false, depth: 0 }
+            locals: { module: Locals, uncaughtOnly: false, depth: 0 },
           });
           var notifier = rollbar.client.notifier;
           rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           nodeThrowNested(rollbar, this.callback);
         },
-        'should include locals': function(_err, r) {
+        'should include locals': function (_err, r) {
           verifyNestedError(r);
         },
-      }
-    }
+      },
+    },
   })
 
   .addBatch({
     'on exception': {
       'promise rejection': {
-        topic: function() {
+        topic: function () {
           var r = new Rollbar({
             accessToken: 'abc123',
             captureUnhandledRejections: true,
-            locals: { module: Locals, uncaughtOnly: false, depth: 0 }
+            locals: { module: Locals, uncaughtOnly: false, depth: 0 },
           });
           var notifier = r.client.notifier;
           r.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           promiseReject(r, this.callback);
         },
-        'should include locals': function(_err, r) {
+        'should include locals': function (_err, r) {
           verifyRejectedPromise(r);
         },
-      }
-    }
+      },
+    },
   })
 
   .addBatch({
     'on exception': {
       'with custom options': {
-        topic: function() {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
             captureUncaught: true,
-            locals: { module: Locals, depth: 2, maxProperties: 5, maxArray: 2 }
+            locals: { module: Locals, depth: 2, maxProperties: 5, maxArray: 2 },
           });
           var notifier = rollbar.client.notifier;
           rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           nodeThrowWithNestedLocals(rollbar, this.callback);
         },
-        'should include locals': function(_err, r) {
+        'should include locals': function (_err, r) {
           var addItemStub = r.addItemStub;
 
           assert.isTrue(addItemStub.called);
           var data = addItemStub.getCall(0).args[3].data;
-          assert.equal(data.body.trace_chain[0].exception.message, 'node error');
+          assert.equal(
+            data.body.trace_chain[0].exception.message,
+            'node error',
+          );
           if (nodeMajorVersion < 10) {
             // Node 8; locals disabled
             var length = data.body.trace_chain[0].frames.length;
-            assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
+            assert.equal(
+              data.body.trace_chain[0].frames[length - 1].locals,
+              undefined,
+            );
           } else {
             var length = data.body.trace_chain[0].frames.length;
-            assert.equal(Object.keys(data.body.trace_chain[0].frames[length-1].locals.obj).length, 5);
-            assert.deepEqual(data.body.trace_chain[0].frames[length-1].locals.obj, { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' });
-            assert.equal(data.body.trace_chain[0].frames[length-1].locals.arr.length, 2);
-            assert.deepEqual(data.body.trace_chain[0].frames[length-1].locals.arr[0], { zero: '<Array object>' });
-            assert.deepEqual(data.body.trace_chain[0].frames[length-1].locals.arr[1], { one: 1 });
-            assert.deepEqual(data.body.trace_chain[0].frames[length-1].locals.password, '********');
-            assert.deepEqual(data.body.trace_chain[0].frames[length-1].locals.sym, 'Symbol(foo)');
+            assert.equal(
+              Object.keys(
+                data.body.trace_chain[0].frames[length - 1].locals.obj,
+              ).length,
+              5,
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals.obj,
+              { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' },
+            );
+            assert.equal(
+              data.body.trace_chain[0].frames[length - 1].locals.arr.length,
+              2,
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals.arr[0],
+              { zero: '<Array object>' },
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals.arr[1],
+              { one: 1 },
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals.password,
+              '********',
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals.sym,
+              'Symbol(foo)',
+            );
           }
           addItemStub.reset();
           Locals.session = undefined;
-        }
-      }
-    }
+        },
+      },
+    },
   })
 
   .addBatch({
     'on exception': {
       'with recursive stack': {
-        topic: function() {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
             captureUncaught: true,
-            locals: Locals
+            locals: Locals,
           });
           var notifier = rollbar.client.notifier;
           rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           nodeThrowRecursionError(rollbar, this.callback);
         },
-        'should include locals': function(_err, r) {
+        'should include locals': function (_err, r) {
           var addItemStub = r.addItemStub;
 
           assert.isTrue(addItemStub.called);
           var data = addItemStub.getCall(0).args[3].data;
-          assert.equal(data.body.trace_chain[0].exception.message, 'deep stack error, limit=3');
-          if (nodeMajorVersion < 10) {
-            // Node 8; locals disabled
-            var length = data.body.trace_chain[0].frames.length;
-            assert.equal(data.body.trace_chain[0].frames[length-1].locals, undefined);
+          assert.equal(
+            data.body.trace_chain[0].exception.message,
+            'deep stack error, limit=3',
+          );
+          var length = data.body.trace_chain[0].frames.length;
+          assert.ok(length > 1);
+
+          if (nodeMajorVersion >= 18) {
+            // Node >=18; locals only in top frame
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals,
+              { curr: 3, limit: 3 },
+            );
+            assert.equal(
+              data.body.trace_chain[0].frames[length - 2].locals,
+              undefined,
+            );
+            assert.equal(
+              data.body.trace_chain[0].frames[length - 3].locals,
+              undefined,
+            );
+          } else if (nodeMajorVersion >= 10) {
+            // Node >=10; locals enabled
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 1].locals,
+              { curr: 3, limit: 3 },
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 2].locals,
+              { curr: 2, limit: 3 },
+            );
+            assert.deepEqual(
+              data.body.trace_chain[0].frames[length - 3].locals,
+              { curr: 1, limit: 3 },
+            );
           } else {
-            var length = data.body.trace_chain[0].frames.length;
-            assert.deepEqual(data.body.trace_chain[0].frames[length-1].locals, { curr: 3, limit: 3 });
-            assert.deepEqual(data.body.trace_chain[0].frames[length-2].locals, { curr: 2, limit: 3 });
-            assert.deepEqual(data.body.trace_chain[0].frames[length-3].locals, { curr: 1, limit: 3 });
+            // Node <=8; locals disabled
+            assert.equal(
+              data.body.trace_chain[0].frames[length - 1].locals,
+              undefined,
+            );
           }
           addItemStub.reset();
           Locals.session = undefined;
-        }
-      }
-    }
+        },
+      },
+    },
   })
 
   .addBatch({
-    'constructor': {
+    constructor: {
       'passing true boolean': {
-        topic: function() {
+        topic: function () {
           return new Locals(true, logger);
         },
-        'should use defaults': function(locals) {
+        'should use defaults': function (locals) {
           verifyDefaultOptions(locals.options);
-        }
+        },
       },
       'passing false boolean': {
-        topic: function() {
+        topic: function () {
           return new Locals(false, logger);
         },
-        'should use defaults': function(locals) {
+        'should use defaults': function (locals) {
           verifyDefaultOptions(locals.options);
-        }
+        },
       },
       'passing empty object': {
-        topic: function() {
+        topic: function () {
           return new Locals({}, logger);
         },
-        'should use defaults': function(locals) {
+        'should use defaults': function (locals) {
           verifyDefaultOptions(locals.options);
-        }
+        },
       },
       'passing depth option': {
-        topic: function() {
+        topic: function () {
           return new Locals({ depth: 0 }, logger);
         },
-        'should use updated depth with remaining defaults': function(locals) {
+        'should use updated depth with remaining defaults': function (locals) {
           var options = locals.options;
 
           assert.equal(options.enabled, true);
@@ -500,13 +702,15 @@ vows.describe('locals')
           assert.equal(options.depth, 0);
           assert.equal(options.maxProperties, 30);
           assert.equal(options.maxArray, 5);
-        }
+        },
       },
       'passing enabled option': {
-        topic: function() {
+        topic: function () {
           return new Locals({ enabled: false }, logger);
         },
-        'should use updated enabled with remaining defaults': function(locals) {
+        'should use updated enabled with remaining defaults': function (
+          locals,
+        ) {
           var options = locals.options;
 
           assert.equal(options.enabled, false);
@@ -514,13 +718,15 @@ vows.describe('locals')
           assert.equal(options.depth, 1);
           assert.equal(options.maxProperties, 30);
           assert.equal(options.maxArray, 5);
-        }
+        },
       },
       'passing uncaughtOnly option': {
-        topic: function() {
+        topic: function () {
           return new Locals({ uncaughtOnly: false }, logger);
         },
-        'should use updated uncaughtOnly with remaining defaults': function(locals) {
+        'should use updated uncaughtOnly with remaining defaults': function (
+          locals,
+        ) {
           var options = locals.options;
 
           assert.equal(options.enabled, true);
@@ -528,19 +734,22 @@ vows.describe('locals')
           assert.equal(options.depth, 1);
           assert.equal(options.maxProperties, 30);
           assert.equal(options.maxArray, 5);
-        }
+        },
       },
       'passing all options': {
-        topic: function() {
-          return new Locals({
-            enabled: false,
-            uncaughtOnly: false,
-            depth: 2,
-            maxProperties: 15,
-            maxArray: 10
-          }, logger);
+        topic: function () {
+          return new Locals(
+            {
+              enabled: false,
+              uncaughtOnly: false,
+              depth: 2,
+              maxProperties: 15,
+              maxArray: 10,
+            },
+            logger,
+          );
         },
-        'should use updated options': function(locals) {
+        'should use updated options': function (locals) {
           var options = locals.options;
 
           assert.equal(options.enabled, false);
@@ -548,16 +757,16 @@ vows.describe('locals')
           assert.equal(options.depth, 2);
           assert.equal(options.maxProperties, 15);
           assert.equal(options.maxArray, 10);
-        }
-      }
-    }
+        },
+      },
+    },
   })
 
   // The following tests stub a singleton (Locals.session.post()), and need to run sequentially.
   // One way to do this in vows is to put each in a separate batch.
   .addBatch({
     'mergeLocals returns error from session.post()': {
-      topic: function() {
+      topic: function () {
         var locals = new Locals({}, logger);
         var err = new Error('post error');
         sinon.stub(Locals.session, 'post').yields(err);
@@ -570,13 +779,13 @@ vows.describe('locals')
 
         locals.mergeLocals(localsMap, stack, key, this.callback);
       },
-      'should callback with error': function(err) {
+      'should callback with error': function (err) {
         assert.instanceOf(err, Error);
         assert.isTrue(err.stack.startsWith('Error: post error'));
         assert.equal(err.message, 'post error');
         sinon.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'mergeLocals called with multiple/complex locals maps present': {
@@ -585,7 +794,7 @@ vows.describe('locals')
       // * Intended locals map key isn't the first or only entry.
       // * Other scopes besides type: 'local' are present.
       // * Transpiled code (Typescript) present in stack
-      topic: function() {
+      topic: function () {
         var getPropertiesResponses = {
           objectId1: [
             localsFixtures.locals.object1,
@@ -599,10 +808,12 @@ vows.describe('locals')
             localsFixtures.locals.string1,
             localsFixtures.locals.array1,
           ],
-        }
+        };
 
         var locals = new Locals({ depth: 0 }, logger);
-        sinon.stub(Locals.session, 'post').callsFake(fakeSessionPostHandler(getPropertiesResponses));
+        sinon
+          .stub(Locals.session, 'post')
+          .callsFake(fakeSessionPostHandler(getPropertiesResponses));
 
         var key1 = 'key1';
         var key2 = 'key2';
@@ -615,11 +826,11 @@ vows.describe('locals')
         var stack = cloneStack(localsFixtures.stacks.complex);
 
         var self = this;
-        locals.mergeLocals(localsMap, stack, key2, function(err) {
+        locals.mergeLocals(localsMap, stack, key2, function (err) {
           self.callback(err, stack);
         });
       },
-      'should callback with merged locals': function(err, stack) {
+      'should callback with merged locals': function (err, stack) {
         if (err) {
           // Ensure unexpected error can be seen.
           console.log(err);
@@ -634,21 +845,23 @@ vows.describe('locals')
         assert.equal(stack[2].locals.bar, '<BarClass object>');
 
         sinon.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'mergeLocals called with simple locals maps present': {
-      topic: function() {
+      topic: function () {
         var getPropertiesResponses = {
           objectId1: [
             localsFixtures.locals.object1,
             localsFixtures.locals.object2,
-          ]
-        }
+          ],
+        };
 
         var locals = new Locals({ depth: 0 }, logger);
-        sinon.stub(Locals.session, 'post').callsFake(fakeSessionPostHandler(getPropertiesResponses));
+        sinon
+          .stub(Locals.session, 'post')
+          .callsFake(fakeSessionPostHandler(getPropertiesResponses));
 
         var key = 'key';
         var localsMap = new Map();
@@ -658,11 +871,11 @@ vows.describe('locals')
         var stack = cloneStack(localsFixtures.stacks.simple);
 
         var self = this;
-        locals.mergeLocals(localsMap, stack, key, function(err) {
+        locals.mergeLocals(localsMap, stack, key, function (err) {
           self.callback(err, stack);
         });
       },
-      'should callback with merged locals': function(err, stack) {
+      'should callback with merged locals': function (err, stack) {
         if (err) {
           // Ensure unexpected error can be seen.
           console.log(err);
@@ -673,12 +886,12 @@ vows.describe('locals')
         assert.equal(stack[0].locals.bar, '<BarClass object>');
 
         sinon.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'mergeLocals called with depth = 1': {
-      topic: function() {
+      topic: function () {
         var getPropertiesResponses = {
           objectId1: [
             localsFixtures.locals.object1,
@@ -693,11 +906,13 @@ vows.describe('locals')
             localsFixtures.locals.array1,
             localsFixtures.locals.null1,
             localsFixtures.locals.function2,
-          ]
-        }
+          ],
+        };
 
         var locals = new Locals({ depth: 1 }, logger);
-        sinon.stub(Locals.session, 'post').callsFake(fakeSessionPostHandler(getPropertiesResponses));
+        sinon
+          .stub(Locals.session, 'post')
+          .callsFake(fakeSessionPostHandler(getPropertiesResponses));
 
         var key = 'key';
         var localsMap = new Map();
@@ -707,27 +922,35 @@ vows.describe('locals')
         var stack = cloneStack(localsFixtures.stacks.simple);
 
         var self = this;
-        locals.mergeLocals(localsMap, stack, key, function(err) {
+        locals.mergeLocals(localsMap, stack, key, function (err) {
           self.callback(err, stack);
         });
       },
-      'should callback with merged locals': function(err, stack) {
+      'should callback with merged locals': function (err, stack) {
         if (err) {
           // Ensure unexpected error can be seen.
           console.log(err);
         }
         assert.isNull(err);
 
-        assert.deepEqual(stack[0].locals.foo, { response: 'success', old: false, func: '<Function object>' });
-        assert.deepEqual(stack[0].locals.bar, { args: '<Array object>', parent: null, asyncFunc: '<AsyncFunction object>' });
+        assert.deepEqual(stack[0].locals.foo, {
+          response: 'success',
+          old: false,
+          func: '<Function object>',
+        });
+        assert.deepEqual(stack[0].locals.bar, {
+          args: '<Array object>',
+          parent: null,
+          asyncFunc: '<AsyncFunction object>',
+        });
 
         sinon.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'mergeLocals called with no locals maps present': {
-      topic: function() {
+      topic: function () {
         var getPropertiesResponses = {
           objectId1: [
             localsFixtures.locals.object1,
@@ -741,10 +964,12 @@ vows.describe('locals')
             localsFixtures.locals.string1,
             localsFixtures.locals.array1,
           ],
-        }
+        };
 
         var locals = new Locals({}, logger);
-        sinon.stub(Locals.session, 'post').callsFake(fakeSessionPostHandler(getPropertiesResponses));
+        sinon
+          .stub(Locals.session, 'post')
+          .callsFake(fakeSessionPostHandler(getPropertiesResponses));
 
         // Test with no maps present. 'key' won't match anything.
         var key = 'key';
@@ -753,11 +978,11 @@ vows.describe('locals')
         var stack = cloneStack(localsFixtures.stacks.complex);
 
         var self = this;
-        locals.mergeLocals(localsMap, stack, key, function(err) {
+        locals.mergeLocals(localsMap, stack, key, function (err) {
           self.callback(err, stack);
         });
       },
-      'should succeed without merged locals': function(err, stack) {
+      'should succeed without merged locals': function (err, stack) {
         if (err) {
           // Ensure unexpected error can be seen.
           console.log(err);
@@ -769,12 +994,12 @@ vows.describe('locals')
         assert.equal(stack[2].locals, undefined);
 
         sinon.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'mergeLocals called with no local scopes in map': {
-      topic: function() {
+      topic: function () {
         var getPropertiesResponses = {
           objectId1: [
             localsFixtures.locals.object1,
@@ -788,10 +1013,12 @@ vows.describe('locals')
             localsFixtures.locals.string1,
             localsFixtures.locals.array1,
           ],
-        }
+        };
 
         var locals = new Locals({}, logger);
-        sinon.stub(Locals.session, 'post').callsFake(fakeSessionPostHandler(getPropertiesResponses));
+        sinon
+          .stub(Locals.session, 'post')
+          .callsFake(fakeSessionPostHandler(getPropertiesResponses));
 
         var key = 'key';
         var localsMap = new Map();
@@ -801,11 +1028,11 @@ vows.describe('locals')
         var stack = cloneStack(localsFixtures.stacks.complex);
 
         var self = this;
-        locals.mergeLocals(localsMap, stack, key, function(err) {
+        locals.mergeLocals(localsMap, stack, key, function (err) {
           self.callback(err, stack);
         });
       },
-      'should succeed without merged locals': function(err, stack) {
+      'should succeed without merged locals': function (err, stack) {
         if (err) {
           // Ensure unexpected error can be seen.
           console.log(err);
@@ -817,12 +1044,12 @@ vows.describe('locals')
         assert.equal(stack[2].locals, undefined);
 
         sinon.restore();
-      }
-    }
+      },
+    },
   })
   .addBatch({
     'currentLocalsMap called with no local scopes in map': {
-      topic: function() {
+      topic: function () {
         var locals = new Locals({}, logger);
 
         // Ensure empty map, as vows uses the same class object between tests.
@@ -830,12 +1057,12 @@ vows.describe('locals')
 
         return locals;
       },
-      'should return empty map': function(locals) {
+      'should return empty map': function (locals) {
         var localsMap = locals.currentLocalsMap();
 
         assert.instanceOf(localsMap, Map);
         assert.equal(localsMap.size, 0);
-      }
-    }
+      },
+    },
   })
-  .export(module, {error: false});
+  .export(module, { error: false });