rollbar 2.26.3 → 3.0.0-alpha.1

package/test/server.transforms.test.js

@@ -1,1099 +0,0 @@
-"use strict";
-
-var assert = require('assert');
-var util = require('util');
-var vows = require('vows');
-var sinon = require('sinon');
-var t = require('../src/server/transforms');
-
-process.env.NODE_ENV = process.env.NODE_ENV || 'test-node-env';
-var rollbar = require('../src/server/rollbar');
-var _ = require('../src/utility');
-
-function CustomError(message, nested) {
-  rollbar.Error.call(this, message, nested);
-}
-util.inherits(CustomError, rollbar.Error);
-
-async function wait(ms) {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms);
-  });
-}
-
-async function throwInScriptFile(rollbar, filepath, callback) {
-  setTimeout(function () {
-    var error = require(filepath);
-    error();
-  }, 10);
-  await wait(500);
-  callback(rollbar);
-}
-
-var nodeVersion = function () {
-  var version = process.versions.node.split('.');
-
-  return [
-    parseInt(version[0]),
-    parseInt(version[1]),
-    parseInt(version[2]),
-  ];
-}();
-
-var isMinNodeVersion = function(major, minor) {
-  return (
-    nodeVersion[0] > major || (nodeVersion[0] === major && nodeVersion[1] >= minor)
-  );
-}
-
-vows.describe('transforms')
-  .addBatch({
-    'baseData': {
-      'options': {
-        'defaults': {
-          topic: function() {
-            return rollbar.defaultOptions;
-          },
-          'item': {
-            'empty': {
-              topic: function(options) {
-                var item = {};
-                t.baseData(item, options, this.callback);
-              },
-              'should have a timestamp': function(err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.notEqual(item.data.timestamp, undefined);
-              },
-              'should have an error level': function(err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.equal(item.data.level, 'error');
-              },
-              'should have some defaults': function(err, item) {
-                assert.ifError(err);
-                var data = item.data;
-                assert.equal(data.environment, process.env.NODE_ENV);
-                assert.equal(data.framework, 'node-js');
-                assert.equal(data.language, 'javascript');
-                assert.ok(data.server);
-                assert.ok(data.server.host);
-                assert.ok(data.server.pid);
-              }
-            },
-            'with values': {
-              topic: function(options) {
-                var item = {
-                  level: 'critical',
-                  framework: 'star-wars',
-                  uuid: '12345',
-                  environment: 'production',
-                  custom: {
-                    one: 'a1',
-                    stuff: 'b2',
-                    language: 'english'
-                  }
-                };
-                t.baseData(item, options, this.callback);
-              },
-              'should have a critical level': function(err, item) {
-                assert.ifError(err);
-                assert.equal(item.data.level, 'critical');
-              },
-              'should have the defaults overriden by the item': function(err, item) {
-                assert.ifError(err);
-                assert.equal(item.data.environment, 'production');
-                assert.equal(item.data.framework, 'star-wars');
-                assert.equal(item.data.language, 'javascript');
-                assert.equal(item.data.uuid, '12345');
-              },
-              'should have data from custom': function(err, item) {
-                assert.equal(item.data.one, 'a1');
-                assert.equal(item.data.stuff, 'b2');
-                assert.notEqual(item.data.language, 'english');
-              }
-            }
-          }
-        },
-        'with values': {
-          topic: function() {
-            return _.merge(rollbar.defaultOptions, {
-              payload: {
-                environment: 'payload-prod',
-              },
-              framework: 'opt-node',
-              host: 'opt-host',
-              branch: 'opt-master'
-            });
-          },
-          'item': {
-            'empty': {
-              topic: function(options) {
-                var item = {};
-                t.baseData(item, options, this.callback);
-              },
-              'should have a timestamp': function(err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.notEqual(item.data.timestamp, undefined);
-              },
-              'should have an error level': function(err, item) {
-                assert.ifError(err);
-                assert.notEqual(item.data, undefined);
-                assert.equal(item.data.level, 'error');
-              },
-              'should have data from options and defaults': function(err, item) {
-                assert.ifError(err);
-                var data = item.data;
-                assert.equal(data.environment, 'payload-prod');
-                assert.equal(data.framework, 'opt-node');
-                assert.equal(data.language, 'javascript');
-                assert.ok(data.server);
-                assert.equal(data.server.host, 'opt-host');
-                assert.equal(data.server.branch, 'opt-master');
-                assert.ok(data.server.pid);
-              }
-            },
-            'with values': {
-              topic: function(options) {
-                var item = {
-                  level: 'critical',
-                  environment: 'production',
-                  framework: 'star-wars',
-                  uuid: '12345',
-                  custom: {
-                    one: 'a1',
-                    stuff: 'b2',
-                    language: 'english'
-                  }
-                };
-                t.baseData(item, options, this.callback);
-              },
-              'should have a critical level': function(err, item) {
-                assert.ifError(err);
-                assert.equal(item.data.level, 'critical');
-              },
-              'should have the defaults overriden by the item': function(err, item) {
-                assert.ifError(err);
-                assert.equal(item.data.environment, 'production');
-                assert.equal(item.data.framework, 'star-wars');
-                assert.equal(item.data.language, 'javascript');
-                assert.equal(item.data.uuid, '12345');
-              },
-              'should have data from custom': function(err, item) {
-                assert.equal(item.data.one, 'a1');
-                assert.equal(item.data.stuff, 'b2');
-                assert.notEqual(item.data.language, 'english');
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-  .addBatch({
-    'addBody': {
-      'options': {
-        'anything': {
-          topic: function() {
-            return {whatever: 'stuff'};
-          },
-          'item': {
-            'with stackInfo': {
-              topic: function(options) {
-                var item = {stackInfo: [{message: 'hey'}]};
-                t.addBody(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should set the trace_chain': function(err, item) {
-                assert.ok(item.data.body.trace_chain);
-              },
-              'should not set a message': function(err, item) {
-                assert.ok(!item.data.body.message);
-              }
-            },
-            'with no stackInfo': {
-              topic: function(options) {
-                var item = {message: 'hello'};
-                t.addBody(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should not set the trace_chain': function(err, item) {
-                assert.ok(!item.data.body.trace_chain);
-              },
-              'should set a message': function(err, item) {
-                assert.ok(item.data.body.message);
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-  .addBatch({
-    'addMessageData': {
-      'options': {
-        'anything': {
-          topic: function() {
-            return {random: 'stuff'};
-          },
-          'item': {
-            'no message': {
-              topic: function(options) {
-                var item = {err: 'stuff', not: 'a message'};
-                t.addMessageData(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should add an empty body': function(err, item) {
-                assert.ok(item.data.body);
-              }
-            },
-            'with a message': {
-              topic: function(options) {
-                var item = {message: 'this is awesome'};
-                t.addMessageData(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should add a body with the message': function(err, item) {
-                assert.equal(item.data.body.message.body, 'this is awesome');
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-  .addBatch({
-    'nodeSourceMaps': {
-      'with original source present': {
-        topic: function() {
-          var Rollbar = new rollbar({
-            accessToken: 'abc123',
-            captureUncaught: true,
-            nodeSourceMaps: true
-          });
-          var queue = Rollbar.client.notifier.queue;
-          Rollbar.addItemStub = sinon.stub(queue, 'addItem');
-
-          throwInScriptFile(Rollbar, '../examples/node-typescript/dist/index',
-            this.callback);
-        },
-        'should map the stack with context': function(r) {
-          var addItem = r.addItemStub;
-
-          assert.isTrue(addItem.called);
-          if (addItem.called) {
-            var frame = addItem.getCall(0).args[0].body.trace_chain[0].frames.pop();
-            assert.ok(frame.filename.includes('src/index.ts'));
-            assert.equal(frame.lineno, 10);
-            assert.equal(frame.colno, 22);
-            assert.equal(frame.code, "  var error = <Error> new CustomError('foo');");
-            assert.equal(frame.context.pre[0], '    }');
-            assert.equal(frame.context.pre[1], '  }');
-            assert.equal(frame.context.pre[2],
-              '  // TypeScript code snippet will include `<Error>`');
-            assert.equal(frame.context.post[0], '  throw error;');
-            assert.equal(frame.context.post[1], '}');
-
-            var sourceMappingURLs = addItem.getCall(0).args[0].notifier.diagnostic
-              .node_source_maps.source_mapping_urls;
-            var urls = Object.keys(sourceMappingURLs);
-            assert.ok(urls[0].includes('index.js'));
-            assert.ok(sourceMappingURLs[urls[0]].includes('index.js.map'));
-            assert.ok(urls[1].includes('server.transforms.test.js'));
-            assert.ok(sourceMappingURLs[urls[1]].includes('not found'));
-
-            // Node until v12 will have 'timers.js' here.
-            // Node 12 - 14 will have 'internal/timers.js' here.
-            // Starting in v16, this is 'node:internal/timers'.
-            // This assert works for all and is specific enough for this test case.
-            assert.ok(urls[2].includes('timers'));
-            assert.ok(sourceMappingURLs[urls[2]].includes('not found'));
-          }
-          addItem.reset();
-        }
-      }
-    }
-  })
-  .addBatch({
-    'nodeSourceMaps': {
-      'using sourcesContent': {
-        topic: function() {
-          var Rollbar = new rollbar({
-            accessToken: 'abc123',
-            captureUncaught: true,
-            nodeSourceMaps: true
-          });
-          var queue = Rollbar.client.notifier.queue;
-          Rollbar.addItemStub = sinon.stub(queue, 'addItem');
-
-          throwInScriptFile(Rollbar, '../examples/node-dist/index', this.callback);
-        },
-        'should map the stack with context': function(r) {
-          var addItem = r.addItemStub;
-
-          assert.isTrue(addItem.called);
-          if (addItem.called) {
-            var frame = addItem.getCall(0).args[0].body.trace_chain[0].frames.pop();
-            assert.ok(frame.filename.includes('src/index.ts'));
-            assert.equal(frame.lineno, 10);
-            assert.equal(frame.colno, 22);
-            assert.equal(frame.code, "  var error = <Error> new CustomError('foo');");
-            assert.equal(frame.context.pre[0], '    }');
-            assert.equal(frame.context.pre[1], '  }');
-            assert.equal(frame.context.pre[2],
-              '  // TypeScript code snippet will include `<Error>`');
-            assert.equal(frame.context.post[0], '  throw error;');
-            assert.equal(frame.context.post[1], '}');
-
-            var sourceMappingURLs = addItem.getCall(0).args[0].notifier.diagnostic
-              .node_source_maps.source_mapping_urls;
-            var urls = Object.keys(sourceMappingURLs);
-            assert.ok(urls.length === 1);
-            assert.ok(urls[0].includes('index.js'));
-            assert.ok(sourceMappingURLs[urls[0]].includes('index.js.map'));
-          }
-          addItem.reset();
-        }
-      }
-    }
-  })
-  .addBatch({
-    'handleItemWithError': {
-      'options': {
-        'anything': {
-          topic: function() {
-            return {
-              some: 'stuff',
-              captureIp: true,
-            };
-          },
-          'item': {
-            'no error': {
-              topic: function(options) {
-                var item = {
-                  data: {body: {yo: 'hey'}},
-                  message: 'hey'
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should not change the item': function(err, item) {
-                assert.equal(item.data.body.yo, 'hey');
-              }
-            },
-            'with a simple error': {
-              topic: function (options) {
-                var item = {
-                  data: {body: {}},
-                  err: new Error('wookie')
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should add some data to the trace_chain': function(err, item) {
-                assert.ok(item.stackInfo);
-              }
-            },
-            'with a normal error': {
-              topic: function (options) {
-                var test = function() {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = e;
-                }
-                var item = {
-                  data: {body: {}},
-                  err: err
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should add some data to the trace_chain': function(err, item) {
-                assert.ok(item.stackInfo);
-              }
-            },
-            'with a nested error': {
-              topic: function (options) {
-                var test = function() {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = new CustomError('nested-message', e);
-                }
-                var item = {
-                  data: {body: {}},
-                  err: err
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should have the right data in the trace_chain': function(err, item) {
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 2);
-                assert.equal(trace_chain[0].exception.class, 'CustomError');
-                assert.equal(trace_chain[0].exception.message, 'nested-message');
-                assert.equal(trace_chain[1].exception.class, 'ReferenceError');
-              }
-            },
-            'with a null nested error': {
-              topic: function (options) {
-                var err = new CustomError('With null nested error');
-
-                // Set nested to null for the test
-                err.nested = null;
-
-                var item = {
-                  data: {body: {}},
-                  err: err
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should have the right data in the trace_chain': function(err, item) {
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 1);
-                assert.equal(trace_chain[0].exception.class, 'CustomError');
-              }
-            },
-            'with error context': {
-              topic: function (options) {
-                var test = function() {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = new CustomError('nested-message', e);
-                  e.rollbarContext = { err1: 'nested context' };
-                  err.rollbarContext = { err2: 'error context' };
-                }
-                var item = {
-                  data: {body: {}},
-                  err: err
-                };
-                options.addErrorContext = true;
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should add the error context': function(err, item) {
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 2);
-                assert.equal(item.data.custom.err1, 'nested context');
-                assert.equal(item.data.custom.err2, 'error context');
-              }
-            },
-            'with an error cause': {
-              topic: function (options) {
-                var test = function() {
-                  var x = thisVariableIsNotDefined;
-                };
-                var err;
-                try {
-                  test();
-                } catch (e) {
-                  err = new Error('cause message', { cause: e });
-                  e.rollbarContext = { err1: 'cause context' };
-                  err.rollbarContext = { err2: 'error context' };
-                }
-                var item = {
-                  data: {body: {}},
-                  err: err
-                };
-                t.handleItemWithError(item, options, this.callback);
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should have the right data in the trace_chain': function(err, item) {
-                // Error cause was introduced in Node 16.9.
-                if (!isMinNodeVersion(16, 9)) return;
-
-                var trace_chain = item.stackInfo;
-                assert.lengthOf(trace_chain, 2);
-                assert.equal(trace_chain[0].exception.class, 'Error');
-                assert.equal(trace_chain[0].exception.message, 'cause message');
-                assert.equal(trace_chain[1].exception.class, 'ReferenceError');
-                assert.equal(item.data.custom.err1, 'cause context');
-                assert.equal(item.data.custom.err2, 'error context');
-              }
-            },
-          }
-        }
-      }
-    }
-  })
-  .addBatch({
-    'addRequestData': {
-      'options': {
-        'without custom addRequestData method': {
-          'without scrub fields': {
-            topic: function() {
-              return {
-                nothing: 'here',
-                captureEmail: true,
-                captureUsername: true,
-                captureIp: true
-              };
-            },
-            'item': {
-              'without a request': {
-                topic: function(options) {
-                  var item = {
-                    data: {body: {message: 'hey'}}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should not change the item': function(err, item) {
-                  assert.equal(item.request, undefined);
-                  assert.equal(item.data.request, undefined);
-                }
-              },
-              'with an empty request object': {
-                topic: function(options) {
-                  var item = {
-                    request: {},
-                    data: {body: {message: 'hey'}}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should not change request object': function(err, item) {
-                  assert.equal(item.request.headers, undefined);
-                }
-              },
-              'with a request': {
-                topic: function(options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345'
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.1',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else'
-                      },
-                      route: { path: '/api/:bork' },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com'
-                      }
-                    },
-                    stuff: 'hey',
-                    data: {other: 'thing'}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function(err, item) {
-                  assert.ok(item.data.request);
-                },
-                'should set a person based on request user': function(err, item) {
-                  assert.equal(item.data.person.id, 42);
-                  assert.equal(item.data.person.email, 'fake@example.com');
-                },
-                'should set some fields based on request data': function(err, item) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/some/endpoint');
-                  assert.equal(r.user_ip, '192.192.192.1');
-                  assert.ok(r.GET);
-
-                  assert.equal(item.data.context, '/api/:bork');
-                },
-              },
-              'with a request for a nested router with a baseURL': {
-                topic: function(options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345'
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      baseUrl: '/nested',
-                      ip: '192.192.192.1',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else'
-                      },
-                      route: { path: '/api/:bork' },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com'
-                      }
-                    },
-                    stuff: 'hey',
-                    data: {other: 'thing'}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function(err, item) {
-                  assert.ok(item.data.request);
-                },
-                'should set some fields based on request data': function(err, item) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/nested/some/endpoint');
-                  assert.equal(item.data.context, '/nested/api/:bork');
-                },
-              },
-              'with a request like from hapi': {
-                topic: function(options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345'
-                      },
-                      protocol: 'https',
-                      url: {
-                        protocol: null,
-                        slashes: null,
-                        auth: null,
-                        host: null,
-                        port: null,
-                        hostname: null,
-                        hash: null,
-                        search: '',
-                        query: {},
-                        pathname: '/some/endpoint',
-                        path: '/some/endpoint',
-                        href: '/some/endpoint'
-                      },
-                      ip: '192.192.192.1',
-                      method: 'POST',
-                      payload: {
-                        token: 'abc123',
-                        something: 'else'
-                      },
-                      route: { path: '/api/:bork' },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com'
-                      }
-                    },
-                    stuff: 'hey',
-                    data: {other: 'thing'}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function(err, item) {
-                  assert.ok(item.data.request);
-                },
-                'should set a person based on request user': function(err, item) {
-                  assert.equal(item.data.person.id, 42);
-                  assert.equal(item.data.person.email, 'fake@example.com');
-                },
-                'should set some fields based on request data': function(err, item) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/some/endpoint');
-                  assert.equal(r.user_ip, '192.192.192.1');
-                  assert.ok(!r.GET);
-                  assert.ok(r.POST);
-
-                  assert.equal(item.data.context, '/api/:bork');
-                },
-              },
-              'with a request with an array body': {
-                topic: function(options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345'
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.1',
-                      method: 'POST',
-                      body: [{
-                        token: 'abc123',
-                        something: 'else'
-                      }, 'otherStuff'],
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com'
-                      }
-                    },
-                    stuff: 'hey',
-                    data: {other: 'thing'}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function(err, item) {
-                  assert.ok(item.data.request);
-                },
-                'should set a person based on request user': function(err, item) {
-                  assert.equal(item.data.person.id, 42);
-                  assert.equal(item.data.person.email, 'fake@example.com');
-                },
-                'should set some fields based on request data': function(err, item) {
-                  var r = item.data.request;
-                  assert.equal(r.url, 'https://example.com/some/endpoint');
-                  assert.equal(r.user_ip, '192.192.192.1');
-                  assert.ok(r.POST);
-                  assert.equal(r.POST['0'].something, 'else');
-                  assert.equal(r.POST['1'], 'otherStuff');
-                },
-              }
-            }
-          },
-          'with scrub fields': {
-            topic: function() {
-              return {
-                scrubHeaders: [
-                  'x-auth-token'
-                ],
-                scrubFields: [
-                  'passwd',
-                  'access_token',
-                  'request.cookie'
-                ]
-              };
-            },
-            'item': {
-              'with a request': {
-                topic: function(options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345'
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.192',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else'
-                      },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com'
-                      }
-                    },
-                    stuff: 'hey',
-                    data: {other: 'thing'}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should have a request object inside data': function(err, item) {
-                  assert.ok(item.data.request);
-                },
-              }
-            }
-          }
-        },
-        'with custom addRequestData': {
-          'with scrub fields': {
-            topic: function() {
-              var customFn = function(i, r) {
-                assert.equal(i.stuff, undefined);
-                assert.equal(i.other, 'thing');
-                i.myRequest = {body: r.body.token};
-              };
-              return {
-                captureIp: true,
-                addRequestData: customFn,
-                scrubFields: [
-                  'passwd',
-                  'access_token',
-                  'token',
-                  'request.cookie'
-                ]
-              };
-            },
-            'item': {
-              'with a request': {
-                topic: function(options) {
-                  var item = {
-                    request: {
-                      headers: {
-                        host: 'example.com',
-                        'x-auth-token': '12345'
-                      },
-                      protocol: 'https',
-                      url: '/some/endpoint',
-                      ip: '192.192.192.192',
-                      method: 'GET',
-                      body: {
-                        token: 'abc123',
-                        something: 'else'
-                      },
-                      user: {
-                        id: 42,
-                        email: 'fake@example.com'
-                      }
-                    },
-                    stuff: 'hey',
-                    data: {other: 'thing'}
-                  };
-                  t.addRequestData(item, options, this.callback);
-                },
-                'should not error': function(err, item) {
-                  assert.ifError(err);
-                },
-                'should do what the function does': function(err, item) {
-                  assert.equal(item.data.request, undefined);
-                  assert.equal(item.data.myRequest.body, 'abc123');
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-  .addBatch({
-    'scrubPayload': {
-      'options': {
-        'without scrub fields': {
-          topic: function() {
-            return rollbar.defaultOptions;
-          },
-          'item': {
-            topic: function(options) {
-              var item = {
-                data: {
-                  body: {
-                    message: 'hey',
-                    password: '123',
-                    secret: {stuff: 'here'}
-                  }
-                }
-              };
-              t.scrubPayload(item, options, this.callback);
-            },
-            'should not error': function(err, item) {
-              assert.ifError(err);
-            },
-            'should not scrub okay keys': function(err, item) {
-              assert.equal(item.data.body.message, 'hey');
-            },
-            'should scrub key/value based on defaults': function(err, item) {
-              assert.matches(item.data.body.password, /\*+/);
-              assert.matches(item.data.body.secret, /\*+/);
-            }
-          }
-        },
-        'with scrub fields': {
-          topic: function() {
-            return {
-              captureIp: true,
-              scrubHeaders: [
-                'x-auth-token'
-              ],
-              scrubFields: [
-                'passwd',
-                'access_token',
-                'request.cookie',
-                'sauce'
-              ],
-              scrubRequestBody: true
-            };
-          },
-          'item': {
-            'with a request': {
-              topic: function(options) {
-                var item = {
-                  request: {
-                    headers: {
-                      host: 'example.com',
-                      'x-auth-token': '12345'
-                    },
-                    protocol: 'https',
-                    url: '/some/endpoint',
-                    ip: '192.192.192.192',
-                    method: 'GET',
-                    body: {
-                      token: 'abc123',
-                      something: 'else'
-                    },
-                    user: {
-                      id: 42,
-                      email: 'fake@example.com'
-                    }
-                  },
-                  stuff: 'hey',
-                  data: {
-                    other: 'thing',
-                    sauce: 'secrets',
-                    someParams: 'foo=okay&passwd=iamhere'
-                  }
-                };
-                t.addRequestData(item, options, function(e, i) {
-                  if (e) {
-                    this.callback(e);
-                    return;
-                  }
-                  t.scrubPayload(i, options, this.callback)
-                }.bind(this));
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should have a request object inside data': function(err, item) {
-                assert.ok(item.data.request);
-              },
-              'should scrub based on the options': function(err, item) {
-                var r = item.data.request;
-                assert.equal(r.GET.token, 'abc123');
-                assert.match(r.headers['x-auth-token'], /\*+/);
-                assert.equal(r.headers['host'], 'example.com');
-                assert.match(item.data.sauce, /\*+/);
-                assert.equal(item.data.other, 'thing');
-                assert.match(item.data.someParams, /foo=okay&passwd=\*+/);
-              }
-            },
-            'with a json request body': {
-              topic: function(options) {
-                var requestBody = JSON.stringify({
-                  token: 'abc123',
-                  something: 'else',
-                  passwd: '123456'
-                });
-                var item = {
-                  request: {
-                    headers: {
-                      host: 'example.com',
-                      'content-type': 'application/json',
-                      'x-auth-token': '12345'
-                    },
-                    protocol: 'https',
-                    url: '/some/endpoint',
-                    ip: '192.192.192.192',
-                    method: 'GET',
-                    body: requestBody,
-                    user: {
-                      id: 42,
-                      email: 'fake@example.com'
-                    }
-                  },
-                  stuff: 'hey',
-                  data: {
-                    other: 'thing',
-                    sauce: 'secrets',
-                    someParams: 'foo=okay&passwd=iamhere'
-                  }
-                };
-                t.addRequestData(item, options, function(e, i) {
-                  if (e) {
-                    this.callback(e);
-                    return;
-                  }
-                  t.scrubPayload(i, options, this.callback)
-                }.bind(this));
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should have a request object inside data': function(err, item) {
-                assert.ok(item.data.request);
-              },
-              'should scrub based on the options': function(err, item) {
-                var r = item.data.request;
-                assert.match(r.headers['x-auth-token'], /\*+/);
-                assert.equal(r.headers['host'], 'example.com');
-                assert.match(item.data.sauce, /\*+/);
-                assert.equal(item.data.other, 'thing');
-                assert.match(item.data.someParams, /foo=okay&passwd=\*+/);
-
-                var requestBody = JSON.parse(item.data.request.body);
-                assert.match(requestBody.passwd, /\*+/);
-              }
-            },
-            'with a bad json request body': {
-              topic: function(options) {
-                var requestBody = 'not valid json';
-                var item = {
-                  request: {
-                    headers: {
-                      'content-type': 'application/json'
-                    },
-                    protocol: 'https',
-                    url: '/some/endpoint',
-                    ip: '192.192.192.192',
-                    method: 'GET',
-                    body: requestBody
-                  }
-                };
-                t.addRequestData(item, options, function(e, i) {
-                  if (e) {
-                    this.callback(e);
-                    return;
-                  }
-                  t.scrubPayload(i, options, this.callback)
-                }.bind(this));
-              },
-              'should not error': function(err, item) {
-                assert.ifError(err);
-              },
-              'should have a request object inside data': function(err, item) {
-                assert.ok(item.data.request);
-              },
-              'should delete the body and add a diagnostic error': function(err, item) {
-                var requestBody = JSON.parse(item.data.request.body);
-                assert.equal(requestBody, null);
-                assert.match(item.data.request.error, /request.body parse failed/);
-              }
-            }
-          }
-        }
-      }
-    }
-  })
-  .export(module, {error: false});