rollbar 2.26.2 → 2.26.4

package/test/server.rollbar.test.js

@@ -19,42 +19,46 @@ const ValidOpenTracingTracerStub = {
           context: () => {
             return {
               toTraceId: () => DUMMY_TRACE_ID,
-              toSpanId: () => DUMMY_SPAN_ID
-            }
-          }
-        }
-      }
-    }
-  }
+              toSpanId: () => DUMMY_SPAN_ID,
+            };
+          },
+        };
+      },
+    };
+  },
 };
 
 const InvalidOpenTracingTracerStub = {
-  foo: () => {}
+  foo: () => {},
 };
 
 function TestClientGen() {
   var TestClient = function () {
     this.notifier = {
-      addTransform: function() { return this; }
+      addTransform: function () {
+        return this;
+      },
     };
     this.queue = {
-      addPredicate: function() { return this; }
+      addPredicate: function () {
+        return this;
+      },
     };
     this.logCalls = [];
     var logs = 'log,debug,info,warn,warning,error,critical'.split(',');
-    for(var i=0, len=logs.length; i < len; i++) {
+    for (var i = 0, len = logs.length; i < len; i++) {
       var fn = logs[i].slice(0);
-      this[fn] = function(fn, item) {
-        this.logCalls.push({func: fn, item: item});
-      }.bind(this, fn)
+      this[fn] = function (fn, item) {
+        this.logCalls.push({ func: fn, item: item });
+      }.bind(this, fn);
     }
-    this.buildJsonPayload = function(obj) {
-      this.logCalls.push({item: obj});
+    this.buildJsonPayload = function (obj) {
+      this.logCalls.push({ item: obj });
     };
-    this.sendJsonPayload = function(json) {
-      this.logCalls.push({item: json});
+    this.sendJsonPayload = function (json) {
+      this.logCalls.push({ item: json });
     };
-    this.clearLogCalls = function() {
+    this.clearLogCalls = function () {
       this.logCalls = [];
     };
     this.tracer = ValidOpenTracingTracerStub;
@@ -64,7 +68,7 @@ function TestClientGen() {
 }
 
 async function wait(ms) {
-  return new Promise(resolve => {
+  return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
@@ -83,190 +87,223 @@ async function nodeThrow(rollbar, callback) {
   callback(rollbar);
 }
 
-vows.describe('rollbar')
+vows
+  .describe('rollbar')
   .addBatch({
-    'constructor': {
+    constructor: {
       'with accessToken': {
-        topic: function() {
+        topic: function () {
           return new Rollbar('abc123');
         },
-        'should have log method': function(r) {
+        'should have log method': function (r) {
           assert.isFunction(r.log);
         },
-        'should have error method': function(r) {
+        'should have error method': function (r) {
           assert.isFunction(r.error);
         },
-        'should have buildJsonPayload method': function(r) {
+        'should have buildJsonPayload method': function (r) {
           assert.isFunction(r.buildJsonPayload);
         },
-        'should have sendJsonPayload method': function(r) {
+        'should have sendJsonPayload method': function (r) {
           assert.isFunction(r.sendJsonPayload);
         },
-        'should have accessToken in options': function(r) {
+        'should have accessToken in options': function (r) {
           assert.equal('abc123', r.options.accessToken);
-        }
+        },
       },
       'with options': {
-        topic: function() {
-          return new Rollbar({accessToken: 'abc123'});
+        topic: function () {
+          return new Rollbar({ accessToken: 'abc123' });
         },
-        'should have log method': function(r) {
+        'should have log method': function (r) {
           assert.isFunction(r.log);
         },
-        'should have error method': function(r) {
+        'should have error method': function (r) {
           assert.isFunction(r.error);
         },
-        'should have accessToken in options': function(r) {
+        'should have accessToken in options': function (r) {
           assert.equal('abc123', r.options.accessToken);
         },
-        'should set environment based on default': function(r) {
+        'should set environment based on default': function (r) {
           assert.equal(process.env.NODE_ENV, r.options.environment);
-        }
+        },
       },
       'with more options': {
-        topic: function() {
-          return new Rollbar({accessToken: 'abc123', environment: 'fake-env'});
+        topic: function () {
+          return new Rollbar({
+            accessToken: 'abc123',
+            environment: 'fake-env',
+          });
         },
-        'should have log method': function(r) {
+        'should have log method': function (r) {
           assert.isFunction(r.log);
         },
-        'should have error method': function(r) {
+        'should have error method': function (r) {
           assert.isFunction(r.error);
         },
-        'should have accessToken in options': function(r) {
+        'should have accessToken in options': function (r) {
           assert.equal('abc123', r.options.accessToken);
         },
-        'should set environment based on options': function(r) {
+        'should set environment based on options': function (r) {
           assert.equal('fake-env', r.options.environment);
         },
-        'should set configured options': function(r) {
+        'should set configured options': function (r) {
           assert.equal('fake-env', r.options._configuredOptions.environment);
-        }
+        },
       },
       'with deprecated options': {
-        topic: function() {
+        topic: function () {
           return new Rollbar({
             hostWhiteList: ['foo'],
-            hostBlackList: ['bar']
+            hostBlackList: ['bar'],
           });
         },
-        'should replace options': function(r) {
+        'should replace options': function (r) {
           assert.equal(r.options.hostWhiteList, undefined);
           assert.equal(r.options.hostBlackList, undefined);
           assert.equal(r.options.hostSafeList, 'foo');
           assert.equal(r.options.hostBlockList, 'bar');
-        }
+        },
       },
       'with valid tracer': {
         topic: function () {
-          var rollbar = new Rollbar({ captureUncaught: true, environment: 'fake-env', tracer: ValidOpenTracingTracerStub });
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+            tracer: ValidOpenTracingTracerStub,
+          });
           return rollbar;
         },
         'should configure tracer': function (r) {
           assert.ok(typeof r.client.tracer === 'object');
-        }
+        },
       },
       'with invalid tracer': {
         topic: function () {
-          var rollbar = new Rollbar({ captureUncaught: true, environment: 'fake-env', tracer: InvalidOpenTracingTracerStub });
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+            tracer: InvalidOpenTracingTracerStub,
+          });
           return rollbar;
         },
         'should configure tracer': function (r) {
           assert.equal(null, r.client.tracer);
-        }
-      }
+        },
+      },
     },
-    'configure': {
+    configure: {
       'with updated options': {
-        topic: function() {
-          var rollbar = new Rollbar({captureUncaught: true, environment: 'fake-env'});
-          rollbar.configure({captureUncaught: false, environment: 'new-env'});
+        topic: function () {
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+          });
+          rollbar.configure({ captureUncaught: false, environment: 'new-env' });
           return rollbar;
         },
-        'should set configured options': function(r) {
+        'should set configured options': function (r) {
           assert.equal('new-env', r.options._configuredOptions.environment);
           assert.equal(false, r.options._configuredOptions.captureUncaught);
-        }
+        },
       },
       'with deprecated options': {
-        topic: function() {
+        topic: function () {
           var rollbar = new Rollbar({ captureUncaught: true });
           rollbar.configure({
             hostWhiteList: ['foo'],
-            hostBlackList: ['bar']
+            hostBlackList: ['bar'],
           });
           return rollbar;
         },
-        'should replace options': function(r) {
+        'should replace options': function (r) {
           assert.equal(r.options.hostWhiteList, undefined);
           assert.equal(r.options.hostBlackList, undefined);
           assert.equal(r.options.hostSafeList, 'foo');
           assert.equal(r.options.hostBlockList, 'bar');
-        }
+        },
       },
       'with valid tracer': {
-        topic: function() {
-          var rollbar = new Rollbar({ captureUncaught: true, environment: 'fake-env' });
+        topic: function () {
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+          });
           rollbar.configure({ tracer: ValidOpenTracingTracerStub });
           return rollbar;
         },
-        'should configure tracer': function(r) {
+        'should configure tracer': function (r) {
           assert.equal(ValidOpenTracingTracerStub, r.client.tracer);
-        }
+        },
       },
       'with invalid tracer': {
-        topic: function() {
-          var rollbar = new Rollbar({ captureUncaught: true, environment: 'fake-env' });
+        topic: function () {
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+          });
           rollbar.configure({ tracer: InvalidOpenTracingTracerStub });
           return rollbar;
         },
-        'should configure tracer': function(r) {
+        'should configure tracer': function (r) {
           assert.equal(null, r.client.tracer);
-        }
-      }
+        },
+      },
     },
-    'addTracingInfo': {
+    addTracingInfo: {
       'with valid tracer': {
-        topic: function() {
-          var rollbar = new Rollbar({ captureUncaught: true, environment: 'fake-env', tracer: ValidOpenTracingTracerStub });
+        topic: function () {
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+            tracer: ValidOpenTracingTracerStub,
+          });
           return rollbar;
         },
-        'should add trace ID and span ID to custom field on item if no custom field set': function (r) {
-          const item = { uuid: 'some-uuid', custom: null };
-          r.client._addTracingInfo(item);
-          assert.equal(DUMMY_TRACE_ID, item.custom.opentracing_trace_id);
-          assert.equal(DUMMY_SPAN_ID, item.custom.opentracing_span_id);
-        },
-        'should add trace ID and span ID to custom field on item even if already has some custom fields': function(r) {
-          const item = { uuid: 'some-uuid', custom: { foo: 'foo' } };
-          r.client._addTracingInfo(item);
-          assert.equal(DUMMY_TRACE_ID, item.custom.opentracing_trace_id);
-          assert.equal(DUMMY_SPAN_ID, item.custom.opentracing_span_id);
-          assert.equal('foo', item.custom.foo);
-        }
+        'should add trace ID and span ID to custom field on item if no custom field set':
+          function (r) {
+            const item = { uuid: 'some-uuid', custom: null };
+            r.client._addTracingInfo(item);
+            assert.equal(DUMMY_TRACE_ID, item.custom.opentracing_trace_id);
+            assert.equal(DUMMY_SPAN_ID, item.custom.opentracing_span_id);
+          },
+        'should add trace ID and span ID to custom field on item even if already has some custom fields':
+          function (r) {
+            const item = { uuid: 'some-uuid', custom: { foo: 'foo' } };
+            r.client._addTracingInfo(item);
+            assert.equal(DUMMY_TRACE_ID, item.custom.opentracing_trace_id);
+            assert.equal(DUMMY_SPAN_ID, item.custom.opentracing_span_id);
+            assert.equal('foo', item.custom.foo);
+          },
       },
       'with invalid tracer': {
-        topic: function() {
-          var rollbar = new Rollbar({ captureUncaught: true, environment: 'fake-env', tracer: InvalidOpenTracingTracerStub });
+        topic: function () {
+          var rollbar = new Rollbar({
+            captureUncaught: true,
+            environment: 'fake-env',
+            tracer: InvalidOpenTracingTracerStub,
+          });
           return rollbar;
         },
-        'should add trace ID and span ID to custom field on item': function (r) {
+        'should add trace ID and span ID to custom field on item': function (
+          r,
+        ) {
           const item = { uuid: 'some-uuid', custom: {} };
           r.client._addTracingInfo(item);
           assert.equal(undefined, item.custom.opentracing_trace_id);
           assert.equal(undefined, item.custom.opentracing_span_id);
-        }
+        },
       },
     },
-    'log': {
-      topic: function() {
+    log: {
+      topic: function () {
         var client = new (TestClientGen())();
         var rollbar = new Rollbar({ accessToken: 'abc123' }, client);
         return rollbar;
       },
-      'message': {
+      message: {
         'with unordered options': {
-          'should work with custom, request, callback, message ': function(r) {
+          'should work with custom, request, callback, message ': function (r) {
             var message = 'hello';
             var callbackCalled = false;
             var callback = function cb() {
@@ -281,17 +318,17 @@ vows.describe('rollbar')
             assert.deepStrictEqual(item.custom, custom);
             item.callback();
             assert.isTrue(callbackCalled);
-          }
+          },
         },
         'with old option ordering': {
-          'should work': function(r) {
-            var message = 'hello'
-            r.log(message)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.message, message)
+          'should work': function (r) {
+            var message = 'hello';
+            r.log(message);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.message, message);
           },
-          'should work with callback': function(r) {
-            var message = 'hello'
+          'should work with callback': function (r) {
+            var message = 'hello';
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
@@ -302,197 +339,205 @@ vows.describe('rollbar')
             item.callback();
             assert.isTrue(callbackCalled);
           },
-          'should work with request': function(r) {
-            var message = 'hello'
-            var request = { method: 'GET' }
-            r.log(message, request)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.message, message)
-            assert.equal(item.request, request)
+          'should work with request': function (r) {
+            var message = 'hello';
+            var request = { method: 'GET' };
+            r.log(message, request);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.message, message);
+            assert.equal(item.request, request);
           },
-          'should work with request and callback': function(r) {
-            var message = 'hello'
-            var request = { method: 'GET' }
+          'should work with request and callback': function (r) {
+            var message = 'hello';
+            var request = { method: 'GET' };
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
             };
-            r.log(message, request, callback)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.message, message)
-            assert.equal(item.request, request)
+            r.log(message, request, callback);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.message, message);
+            assert.equal(item.request, request);
             item.callback();
             assert.isTrue(callbackCalled);
           },
-          'should work with request and custom': function(r) {
-            var message = 'hello'
-            var request = { method: 'GET' }
-            var custom = { a: 1, b: 2 }
-            r.log(message, request, custom)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.message, message)
-            assert.equal(item.request, request)
-            assert.deepStrictEqual(item.custom, custom)
+          'should work with request and custom': function (r) {
+            var message = 'hello';
+            var request = { method: 'GET' };
+            var custom = { a: 1, b: 2 };
+            r.log(message, request, custom);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.message, message);
+            assert.equal(item.request, request);
+            assert.deepStrictEqual(item.custom, custom);
           },
-          'should work with request and custom and callback': function(r) {
-            var message = 'hello'
-            var request = { method: 'GET' }
-            var custom = { a: 1, b: 2 }
+          'should work with request and custom and callback': function (r) {
+            var message = 'hello';
+            var request = { method: 'GET' };
+            var custom = { a: 1, b: 2 };
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
             };
-            r.log(message, request, custom, callback)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.message, message)
-            assert.equal(item.request, request)
-            assert.deepStrictEqual(item.custom, custom)
+            r.log(message, request, custom, callback);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.message, message);
+            assert.equal(item.request, request);
+            assert.deepStrictEqual(item.custom, custom);
             item.callback();
             assert.isTrue(callbackCalled);
-          }
-        }
+          },
+        },
       },
-      'info': {
-        topic: function() {
+      info: {
+        topic: function () {
           // Uses real client and stubs queue.addItem so transforms can run.
           var rollbar = new Rollbar({
             accessToken: 'abc123',
-            captureUncaught: false
+            captureUncaught: false,
           });
           var notifier = rollbar.client.notifier;
           rollbar.addItemStub = sinon.stub(notifier.queue, 'addItem');
 
           return rollbar;
         },
-        'should send message when called with only null argument': function(r) {
+        'should send message when called with only null argument': function (
+          r,
+        ) {
           var addItemStub = r.addItemStub;
 
           r.info(null);
           assert.isTrue(addItemStub.called);
           if (addItemStub.called) {
-            assert.equal(addItemStub.getCall(0).args[3].data.body.message.body, 'Item sent with null or missing arguments.');
+            assert.equal(
+              addItemStub.getCall(0).args[3].data.body.message.body,
+              'Item sent with null or missing arguments.',
+            );
           }
           addItemStub.reset();
         },
-        'should send message when called with no arguments': function(r) {
+        'should send message when called with no arguments': function (r) {
           var addItemStub = r.addItemStub;
 
           r.info();
           assert.isTrue(addItemStub.called);
           if (addItemStub.called) {
-            assert.equal(addItemStub.getCall(0).args[3].data.body.message.body, 'Item sent with null or missing arguments.');
+            assert.equal(
+              addItemStub.getCall(0).args[3].data.body.message.body,
+              'Item sent with null or missing arguments.',
+            );
           }
           addItemStub.reset();
-        }
+        },
       },
-      'error': {
+      error: {
         'with unordered options': {
-          'should work with custom, request, callback, message ': function(r) {
-            var err = new Error('hello!')
+          'should work with custom, request, callback, message ': function (r) {
+            var err = new Error('hello!');
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
             };
-            var request = { method: 'GET' }
-            var custom = { a: 1, b: 2 }
-            r.log(custom, request, callback, err)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
-            assert.equal(item.request, request)
-            assert.deepStrictEqual(item.custom, custom)
+            var request = { method: 'GET' };
+            var custom = { a: 1, b: 2 };
+            r.log(custom, request, callback, err);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
+            assert.equal(item.request, request);
+            assert.deepStrictEqual(item.custom, custom);
             item.callback();
             assert.isTrue(callbackCalled);
-          }
+          },
         },
         'with old option ordering': {
-          'should work': function(r) {
-            var err = new Error('hello!')
-            r.log(err)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
+          'should work': function (r) {
+            var err = new Error('hello!');
+            r.log(err);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
           },
-          'should work with callback': function(r) {
-            var err = new Error('hello!')
+          'should work with callback': function (r) {
+            var err = new Error('hello!');
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
             };
-            r.log(err, callback)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
+            r.log(err, callback);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
             item.callback();
             assert.isTrue(callbackCalled);
           },
-          'should work with request': function(r) {
-            var err = new Error('hello!')
-            var request = { method: 'GET' }
-            r.log(err, request)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
-            assert.equal(item.request, request)
+          'should work with request': function (r) {
+            var err = new Error('hello!');
+            var request = { method: 'GET' };
+            r.log(err, request);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
+            assert.equal(item.request, request);
           },
-          'should work with request and callback': function(r) {
-            var err = new Error('hello!')
-            var request = { method: 'GET' }
+          'should work with request and callback': function (r) {
+            var err = new Error('hello!');
+            var request = { method: 'GET' };
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
             };
-            r.log(err, request, callback)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
-            assert.equal(item.request, request)
+            r.log(err, request, callback);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
+            assert.equal(item.request, request);
             item.callback();
             assert.isTrue(callbackCalled);
           },
-          'should work with request and custom': function(r) {
-            var err = new Error('hello!')
-            var request = { method: 'GET' }
-            var custom = { a: 1, b: 2 }
-            r.log(err, request, custom)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
-            assert.equal(item.request, request)
-            assert.deepStrictEqual(item.custom, custom)
+          'should work with request and custom': function (r) {
+            var err = new Error('hello!');
+            var request = { method: 'GET' };
+            var custom = { a: 1, b: 2 };
+            r.log(err, request, custom);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
+            assert.equal(item.request, request);
+            assert.deepStrictEqual(item.custom, custom);
           },
-          'should work with request and custom and callback': function(r) {
-            var err = new Error('hello!')
-            var request = { method: 'GET' }
-            var custom = { a: 1, b: 2 }
+          'should work with request and custom and callback': function (r) {
+            var err = new Error('hello!');
+            var request = { method: 'GET' };
+            var custom = { a: 1, b: 2 };
             var callbackCalled = false;
             var callback = function cb() {
               callbackCalled = true;
             };
-            r.log(err, request, custom, callback)
-            var item = r.client.logCalls[r.client.logCalls.length - 1].item
-            assert.equal(item.err, err)
-            assert.equal(item.request, request)
-            assert.deepStrictEqual(item.custom, custom)
+            r.log(err, request, custom, callback);
+            var item = r.client.logCalls[r.client.logCalls.length - 1].item;
+            assert.equal(item.err, err);
+            assert.equal(item.request, request);
+            assert.deepStrictEqual(item.custom, custom);
             item.callback();
             assert.isTrue(callbackCalled);
-          }
-        }
-      }
+          },
+        },
+      },
     },
     // captureUncaught tests are set up using subtopics because Rollbar's node.js handlers
     // are treated as global and concurrent access will lead to handlers being removed
     // unexpectedly. (Subtopics execute sequentially.)
-    'captureUncaught': {
+    captureUncaught: {
       'enabled in constructor': {
-        topic: function() {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
-            captureUncaught: true
+            captureUncaught: true,
           });
           var notifier = rollbar.client.notifier;
           rollbar.logStub = sinon.stub(notifier, 'log');
 
           nodeThrow(rollbar, this.callback);
         },
-        'should have locals disabled': function(r) {
+        'should have locals disabled': function (r) {
           assert.equal(r.client.notifier.locals, undefined);
         },
-        'should log': function(r) {
+        'should log': function (r) {
           var logStub = r.logStub;
 
           assert.isTrue(logStub.called);
@@ -502,14 +547,14 @@ vows.describe('rollbar')
           logStub.reset();
         },
         'disabled in configure': {
-          topic: function(r) {
+          topic: function (r) {
             r.configure({
-              captureUncaught: false
+              captureUncaught: false,
             });
 
             nodeThrow(r, this.callback);
           },
-          'should not log': function(r) {
+          'should not log': function (r) {
             var notifier = r.client.notifier;
             var logStub = r.logStub;
 
@@ -517,61 +562,64 @@ vows.describe('rollbar')
             notifier.log.restore();
           },
           'disabled in constructor': {
-            topic: function() {
+            topic: function () {
               var rollbar = new Rollbar({
                 accessToken: 'abc123',
-                captureUncaught: false
+                captureUncaught: false,
               });
               var notifier = rollbar.client.notifier;
               rollbar.logStub = sinon.stub(notifier, 'log');
 
               nodeThrow(rollbar, this.callback);
             },
-            'should not log': function(r) {
+            'should not log': function (r) {
               var logStub = r.logStub;
 
               assert.isFalse(logStub.called);
               logStub.reset();
             },
             'enabled in configure': {
-              topic: function(r) {
+              topic: function (r) {
                 r.configure({
-                  captureUncaught: true
+                  captureUncaught: true,
                 });
 
                 nodeThrow(r, this.callback);
               },
-              'should log': function(r) {
+              'should log': function (r) {
                 var notifier = r.client.notifier;
                 var logStub = r.logStub;
 
                 assert.isTrue(logStub.called);
                 if (logStub.called) {
-                  assert.equal(logStub.getCall(0).args[0].err.message, 'node error');
+                  assert.equal(
+                    logStub.getCall(0).args[0].err.message,
+                    'node error',
+                  );
                 }
                 notifier.log.restore();
-              }
-            }
-          }
-        }
-      }
+              },
+            },
+          },
+        },
+      },
     },
     // captureUnhandledRejections tests are set up using subtopics because Rollbar's node.js handlers
     // are treated as global and concurrent access will lead to handlers being removed
     // unexpectedly. (Subtopics execute sequentially.)
-    'captureUnhandledRejections': {
+    captureUnhandledRejections: {
       'enabled in constructor': {
-        topic: function() {
+        topic: function () {
           var rollbar = new Rollbar({
             accessToken: 'abc123',
-            captureUnhandledRejections: true
+            captureUnhandledRejections: true,
           });
           var notifier = rollbar.client.notifier;
           rollbar.logStub = sinon.stub(notifier, 'log');
 
           nodeReject(rollbar, this.callback);
         },
-        'should log': function(r) {
+        'should log': function (r) {
           var logStub = r.logStub;
 
           assert.isTrue(logStub.called);
@@ -581,14 +629,14 @@ vows.describe('rollbar')
           logStub.reset();
         },
         'disabled in configure': {
-          topic: function(r) {
+          topic: function (r) {
             r.configure({
-              captureUnhandledRejections: false
+              captureUnhandledRejections: false,
             });
 
             nodeReject(r, this.callback);
           },
-          'should not log': function(r) {
+          'should not log': function (r) {
             var notifier = r.client.notifier;
             var logStub = r.logStub;
 
@@ -596,81 +644,85 @@ vows.describe('rollbar')
             notifier.log.restore();
           },
           'disabled in constructor': {
-            topic: function() {
+            topic: function () {
               var rollbar = new Rollbar({
                 accessToken: 'abc123',
-                captureUnhandledRejections: false
+                captureUnhandledRejections: false,
               });
               var notifier = rollbar.client.notifier;
               rollbar.logStub = sinon.stub(notifier, 'log');
 
               nodeReject(rollbar, this.callback);
             },
-            'should not log': function(r) {
+            'should not log': function (r) {
               var logStub = r.logStub;
 
               assert.isFalse(logStub.called);
               logStub.reset();
             },
             'enabled in configure': {
-              topic: function(r) {
+              topic: function (r) {
                 r.configure({
-                  captureUnhandledRejections: true
+                  captureUnhandledRejections: true,
                 });
 
                 nodeReject(r, this.callback);
               },
-              'should log': function(r) {
+              'should log': function (r) {
                 var notifier = r.client.notifier;
                 var logStub = r.logStub;
 
                 assert.isTrue(logStub.called);
                 if (logStub.called) {
-                  assert.equal(logStub.getCall(0).args[0].err.message, 'node reject');
+                  assert.equal(
+                    logStub.getCall(0).args[0].err.message,
+                    'node reject',
+                  );
                 }
                 notifier.log.restore();
-              }
-            }
-          }
-        }
-      }
+              },
+            },
+          },
+        },
+      },
     },
-    'buildJsonPayload': {
-      topic: function() {
+    buildJsonPayload: {
+      topic: function () {
         var client = new (TestClientGen())();
-        var rollbar = new Rollbar({accessToken: 'abc123'}, client);
+        var rollbar = new Rollbar({ accessToken: 'abc123' }, client);
         return rollbar;
       },
-      'should work': function(r) {
+      'should work': function (r) {
         var obj = { foo: 'bar' };
         r.buildJsonPayload(obj);
         var item = r.client.logCalls[r.client.logCalls.length - 1].item;
         assert.equal(obj, item);
-      }
+      },
     },
-    'sendJsonPayload': {
-      topic: function() {
+    sendJsonPayload: {
+      topic: function () {
         var client = new (TestClientGen())();
-        var rollbar = new Rollbar({accessToken: 'abc123'}, client);
+        var rollbar = new Rollbar({ accessToken: 'abc123' }, client);
         return rollbar;
       },
-      'should work': function(r) {
-        var json = "{ \"foo\": \"bar\" }";
+      'should work': function (r) {
+        var json = '{ "foo": "bar" }';
         r.sendJsonPayload(json);
         var item = r.client.logCalls[r.client.logCalls.length - 1].item;
         assert.equal(json, item);
-      }
+      },
     },
-    'singleton': {
-      topic: function() {
+    singleton: {
+      topic: function () {
         var client = new (TestClientGen())();
-        return Rollbar.init({accessToken: 'abc123'}, client);
+        return Rollbar.init({ accessToken: 'abc123' }, client);
       },
-      'should allow log on constructor to pass through': function(r) {
+      'should allow log on constructor to pass through': function (r) {
         r.log('hello 1');
         Rollbar.log('hello 2');
         assert.equal(r.client.logCalls[0].item.message, 'hello 1');
         assert.equal(r.client.logCalls[1].item.message, 'hello 2');
-      }
-    }
-  }).export(module, {error: false});
+      },
+    },
+  })
+  .export(module, { error: false });