rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.transforms.error.mocha.test.mjs

@@ -0,0 +1,199 @@
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+
+import { expect } from 'chai';
+import * as t from '../src/server/transforms.js';
+import {
+  CustomError,
+  isMinNodeVersion,
+} from './server.transforms.test-utils.mjs';
+
+describe('transforms.handleItemWithError', function () {
+  let options;
+
+  beforeEach(function () {
+    options = {
+      some: 'stuff',
+      captureIp: true,
+    };
+  });
+
+  it('should not change the item with no error', function (done) {
+    const item = {
+      data: { body: { yo: 'hey' } },
+      message: 'hey',
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+      expect(item.data.body.yo).to.equal('hey');
+      done();
+    });
+  });
+
+  it('should add some data to the trace_chain with a simple error', function (done) {
+    const item = {
+      data: { body: {} },
+      err: new Error('wookie'),
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+      expect(item.stackInfo).to.exist;
+      done();
+    });
+  });
+
+  it('should add some data to the trace_chain with a normal error', function (done) {
+    let testError;
+
+    const test = function () {
+      const x = thisVariableIsNotDefined;
+    };
+
+    try {
+      test();
+    } catch (e) {
+      testError = e;
+    }
+
+    const item = {
+      data: { body: {} },
+      err: testError,
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+      expect(item.stackInfo).to.exist;
+      done();
+    });
+  });
+
+  it('should have the right data in the trace_chain with a nested error', function (done) {
+    let testError;
+
+    const test = function () {
+      const x = thisVariableIsNotDefined;
+    };
+
+    try {
+      test();
+    } catch (e) {
+      testError = new CustomError('nested-message', e);
+    }
+
+    const item = {
+      data: { body: {} },
+      err: testError,
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+
+      const trace_chain = item.stackInfo;
+      expect(trace_chain).to.have.lengthOf(2);
+      expect(trace_chain[0].exception.class).to.equal('CustomError');
+      expect(trace_chain[0].exception.message).to.equal('nested-message');
+      expect(trace_chain[1].exception.class).to.equal('ReferenceError');
+
+      done();
+    });
+  });
+
+  it('should have the right data in the trace_chain with a null nested error', function (done) {
+    const err = new CustomError('With null nested error');
+    err.nested = null;
+
+    const item = {
+      data: { body: {} },
+      err: err,
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+
+      const trace_chain = item.stackInfo;
+      expect(trace_chain).to.have.lengthOf(1);
+      expect(trace_chain[0].exception.class).to.equal('CustomError');
+
+      done();
+    });
+  });
+
+  it('should add the error context with error context', function (done) {
+    let testError;
+
+    const test = function () {
+      const x = thisVariableIsNotDefined;
+    };
+
+    try {
+      test();
+    } catch (e) {
+      testError = new CustomError('nested-message', e);
+      e.rollbarContext = { err1: 'nested context' };
+      testError.rollbarContext = { err2: 'error context' };
+    }
+
+    options.addErrorContext = true;
+
+    const item = {
+      data: { body: {} },
+      err: testError,
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+
+      const trace_chain = item.stackInfo;
+      expect(trace_chain).to.have.lengthOf(2);
+      expect(item.data.custom.err1).to.equal('nested context');
+      expect(item.data.custom.err2).to.equal('error context');
+
+      done();
+    });
+  });
+
+  it('should have the right data in the trace_chain with an error cause', function (done) {
+    // Error cause was introduced in Node 16.9.
+    if (!isMinNodeVersion(16, 9)) {
+      this.skip();
+    }
+
+    let testError;
+
+    const test = function () {
+      const x = thisVariableIsNotDefined;
+    };
+
+    try {
+      test();
+    } catch (e) {
+      testError = new Error('cause message', { cause: e });
+      e.rollbarContext = { err1: 'cause context' };
+      testError.rollbarContext = { err2: 'error context' };
+    }
+
+    options.addErrorContext = true;
+
+    const item = {
+      data: { body: {} },
+      err: testError,
+    };
+
+    t.handleItemWithError(item, options, (err, item) => {
+      expect(err).to.not.exist;
+
+      const trace_chain = item.stackInfo;
+      expect(trace_chain).to.have.lengthOf(2);
+      expect(trace_chain[0].exception.class).to.equal('Error');
+      expect(trace_chain[0].exception.message).to.equal('cause message');
+      expect(trace_chain[1].exception.class).to.equal('ReferenceError');
+      expect(item.data.custom.err1).to.equal('cause context');
+      expect(item.data.custom.err2).to.equal('error context');
+
+      done();
+    });
+  });
+});

package/test/server.transforms.request.mocha.test.mjs

@@ -0,0 +1,208 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import * as t from '../src/server/transforms.js';
+import { createTestItem } from './server.transforms.test-utils.mjs';
+
+describe('transforms.addRequestData', function () {
+  describe('without custom addRequestData method', function () {
+    describe('without scrub fields', function () {
+      const options = {
+        nothing: 'here',
+        captureEmail: true,
+        captureUsername: true,
+        captureIp: true,
+      };
+
+      it('should not change the item without a request', function (done) {
+        const item = {
+          data: { body: { message: 'hey' } },
+        };
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+          expect(item.request).to.be.undefined;
+          expect(item.data.request).to.be.undefined;
+          done();
+        });
+      });
+
+      it('should not change the request with an empty request object', function (done) {
+        const item = {
+          request: {},
+          data: { body: { message: 'hey' } },
+        };
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+          expect(item.request.headers).to.be.undefined;
+          done();
+        });
+      });
+
+      it('should have a person, request and context with a request object', function (done) {
+        const item = createTestItem({
+          request: {
+            route: { path: '/api/:bork' },
+          },
+        });
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+
+          const data = item.data;
+          expect(data.person.id).to.equal(42);
+          expect(data.person.email).to.equal('fake@example.com');
+          expect(data.request.url).to.equal(
+            'https://example.com/some/endpoint',
+          );
+          expect(data.request.user_ip).to.equal('192.192.192.1');
+          expect(data.request.GET).to.exist;
+          expect(data.context).to.equal('/api/:bork');
+
+          done();
+        });
+      });
+
+      it('should set some fields based on request data with a request for a nested router with a baseURL', function (done) {
+        const item = createTestItem({
+          request: {
+            baseUrl: '/nested',
+            route: { path: '/api/:bork' },
+          },
+        });
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+          expect(item.data.request.url).to.equal(
+            'https://example.com/nested/some/endpoint',
+          );
+          expect(item.data.context).to.equal('/nested/api/:bork');
+          done();
+        });
+      });
+
+      it('should set a person and some fields based on request data with a request like from hapi', function (done) {
+        const item = createTestItem({
+          request: {
+            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',
+            },
+            method: 'POST',
+            payload: {
+              token: 'abc123',
+              something: 'else',
+            },
+            route: { path: '/api/:bork' },
+          },
+        });
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+
+          const data = item.data;
+          expect(data.person.id).to.equal(42);
+          expect(data.person.email).to.equal('fake@example.com');
+          expect(data.request.url).to.equal(
+            'https://example.com/some/endpoint',
+          );
+          expect(data.request.user_ip).to.equal('192.192.192.1');
+          expect(data.request.GET).to.not.exist;
+          expect(data.request.POST).to.exist;
+          expect(item.data.context).to.equal('/api/:bork');
+
+          done();
+        });
+      });
+
+      it('should set a person and some fields based on request data with a request with an array body', function (done) {
+        const item = createTestItem({
+          request: {
+            method: 'POST',
+            body: [
+              {
+                token: 'abc123',
+                something: 'else',
+              },
+              'otherStuff',
+            ],
+          },
+        });
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+
+          const data = item.data;
+          expect(data.person.id).to.equal(42);
+          expect(data.person.email).to.equal('fake@example.com');
+          expect(data.request.url).to.equal(
+            'https://example.com/some/endpoint',
+          );
+          expect(data.request.user_ip).to.equal('192.192.192.1');
+          expect(data.request.POST).to.exist;
+          expect(data.request.POST['0'].something).to.equal('else');
+          expect(data.request.POST['1']).to.equal('otherStuff');
+
+          done();
+        });
+      });
+    });
+
+    describe('with scrub fields', function () {
+      const options = {
+        scrubHeaders: ['x-auth-token'],
+        scrubFields: ['passwd', 'access_token', 'request.cookie'],
+      };
+
+      it('should create request data without scrubbing even with scrub options', function (done) {
+        const item = createTestItem();
+
+        t.addRequestData(item, options, (err, item) => {
+          expect(err).to.not.exist;
+          // Verify that addRequestData doesn't scrub -
+          // headers should still contain sensitive data
+          expect(item.data.request.headers['x-auth-token']).to.equal('12345');
+          expect(item.data.request.GET.token).to.equal('abc123');
+          done();
+        });
+      });
+    });
+  });
+
+  describe('with custom addRequestData', function () {
+    it('should do what the function does with a request with scrub fields', function (done) {
+      const customFn = function (item, request) {
+        expect(item.stuff).to.be.undefined;
+        expect(item.other).to.equal('thing');
+        item.myRequest = { body: request.body.token };
+      };
+
+      const options = {
+        captureIp: true,
+        addRequestData: customFn,
+        scrubFields: ['passwd', 'access_token', 'token', 'request.cookie'],
+      };
+
+      const item = createTestItem();
+
+      t.addRequestData(item, options, (err, item) => {
+        expect(err).to.not.exist;
+        expect(item.data.request).to.not.exist;
+        expect(item.data.myRequest.body).to.equal('abc123');
+        done();
+      });
+    });
+  });
+});

package/test/server.transforms.scrub.mocha.test.mjs

@@ -0,0 +1,140 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import Rollbar from '../src/server/rollbar.js';
+import * as t from '../src/server/transforms.js';
+import { createTestItem } from './server.transforms.test-utils.mjs';
+
+describe('transforms.scrubPayload', function () {
+  describe('without scrub fields', function () {
+    it('should scrub key/value based on defaults but not okay keys', function (done) {
+      const item = {
+        data: {
+          body: {
+            message: 'hey',
+            password: '123',
+            secret: { stuff: 'here' },
+          },
+        },
+      };
+
+      t.scrubPayload(item, Rollbar.defaultOptions, (err, item) => {
+        expect(err).to.not.exist;
+        expect(item.data.body.message).to.equal('hey');
+        expect(item.data.body.password).to.match(/\*+/);
+        expect(item.data.body.secret).to.match(/\*+/);
+        done();
+      });
+    });
+  });
+
+  describe('with scrub fields', function () {
+    const options = {
+      captureIp: true,
+      scrubHeaders: ['x-auth-token'],
+      scrubFields: ['passwd', 'access_token', 'request.cookie', 'sauce'],
+      scrubRequestBody: true,
+    };
+
+    it('should scrub based on the options with a request', function (done) {
+      const item = createTestItem({
+        data: {
+          other: 'thing',
+          sauce: 'secrets',
+          someParams: 'foo=okay&passwd=iamhere',
+        },
+      });
+
+      t.addRequestData(item, options, (err, item) => {
+        expect(err).to.not.exist;
+
+        t.scrubPayload(item, options, (err, scrubbedItem) => {
+          expect(err).to.not.exist;
+
+          const data = scrubbedItem.data;
+          expect(data.request.GET.token).to.equal('abc123');
+          expect(data.request.headers['x-auth-token']).to.match(/\*+/);
+          expect(data.request.headers['host']).to.equal('example.com');
+          expect(data.sauce).to.match(/\*+/);
+          expect(data.other).to.equal('thing');
+          expect(data.someParams).to.match(/foo=okay&passwd=\*+/);
+
+          done();
+        });
+      });
+    });
+
+    it('should scrub based on the options with a json request body', function (done) {
+      const item = createTestItem({
+        request: {
+          headers: {
+            host: 'example.com',
+            'content-type': 'application/json',
+            'x-auth-token': '12345',
+          },
+          body: JSON.stringify({
+            token: 'abc123',
+            something: 'else',
+            passwd: '123456',
+          }),
+        },
+        data: {
+          other: 'thing',
+          sauce: 'secrets',
+          someParams: 'foo=okay&passwd=iamhere',
+        },
+      });
+
+      t.addRequestData(item, options, (err, item) => {
+        expect(err).to.not.exist;
+
+        t.scrubPayload(item, options, (err, scrubbedItem) => {
+          expect(err).to.not.exist;
+
+          const data = scrubbedItem.data;
+          expect(data.request.headers['x-auth-token']).to.match(/\*+/);
+          expect(data.request.headers['host']).to.equal('example.com');
+          expect(data.sauce).to.match(/\*+/);
+          expect(data.other).to.equal('thing');
+          expect(data.someParams).to.match(/foo=okay&passwd=\*+/);
+
+          const requestBody = JSON.parse(scrubbedItem.data.request.body);
+          expect(requestBody.passwd).to.match(/\*+/);
+
+          done();
+        });
+      });
+    });
+
+    it('should delete the body and add a diagnostic error with a bad json request body', function (done) {
+      const item = {
+        request: {
+          headers: {
+            'content-type': 'application/json',
+          },
+          protocol: 'https',
+          url: '/some/endpoint',
+          ip: '192.192.192.1',
+          method: 'GET',
+          body: 'not valid json',
+        },
+      };
+
+      t.addRequestData(item, options, (err, item) => {
+        expect(err).to.not.exist;
+
+        t.scrubPayload(item, options, (err, scrubbedItem) => {
+          expect(err).to.not.exist;
+
+          const data = scrubbedItem.data;
+          const requestBody = JSON.parse(data.request.body);
+          expect(requestBody).to.be.null;
+          expect(data.request.error).to.match(/request.body parse failed/);
+
+          done();
+        });
+      });
+    });
+  });
+});

package/test/server.transforms.sourcemaps.mocha.test.mjs

@@ -0,0 +1,122 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import Rollbar from '../src/server/rollbar.js';
+import { throwInScriptFile } from './server.transforms.test-utils.mjs';
+
+describe('transforms.nodeSourceMaps', function () {
+  let rollbar;
+  let addItemStub;
+  let mochaHandlers;
+
+  before(function () {
+    // Increase max listeners to avoid warnings during tests
+    // Multiple Rollbar instances are created and each adds handlers
+    process.setMaxListeners(20);
+  });
+
+  after(function () {
+    process.setMaxListeners(10);
+  });
+
+  beforeEach(function () {
+    // Remove Mocha's uncaught exception handlers to prevent interference
+    mochaHandlers = process.listeners('uncaughtException');
+    mochaHandlers.forEach((handler) => {
+      process.removeListener('uncaughtException', handler);
+    });
+
+    rollbar = new Rollbar({
+      accessToken: 'abc123',
+      captureUncaught: true,
+      nodeSourceMaps: true,
+    });
+
+    addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+  });
+
+  afterEach(function () {
+    addItemStub.restore();
+
+    // Restore Mocha's handlers
+    mochaHandlers.forEach((handler) => {
+      process.on('uncaughtException', handler);
+    });
+  });
+
+  it('should map the stack with context when original source is present', async function () {
+    await throwInScriptFile('../examples/node-typescript/dist/index.js');
+
+    expect(addItemStub.called).to.be.true;
+
+    const frame = addItemStub
+      .getCall(0)
+      .args[0].body.trace_chain[0].frames.pop();
+
+    expect(frame.filename).to.include('src/index.ts');
+    expect(frame.lineno).to.equal(10);
+    expect(frame.colno).to.equal(22);
+    expect(frame.code).to.equal(
+      "  var error = <Error> new CustomError('foo');",
+    );
+    expect(frame.context.pre[0]).to.equal('    }');
+    expect(frame.context.pre[1]).to.equal('  }');
+    expect(frame.context.pre[2]).to.equal(
+      '  // TypeScript code snippet will include `<Error>`',
+    );
+    expect(frame.context.post[0]).to.equal('  throw error;');
+    expect(frame.context.post[1]).to.equal('}');
+
+    const sourceMappingURLs =
+      addItemStub.getCall(0).args[0].notifier.diagnostic.node_source_maps
+        .source_mapping_urls;
+    const urls = Object.keys(sourceMappingURLs);
+
+    expect(urls[0]).to.include('index.js');
+    expect(sourceMappingURLs[urls[0]]).to.include('index.js.map');
+    expect(urls[1]).to.include('server.transforms.test-utils.mjs');
+    expect(sourceMappingURLs[urls[1]]).to.include('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.
+    expect(urls[2]).to.include('timers');
+    expect(sourceMappingURLs[urls[2]]).to.include('not found');
+  });
+
+  it('should map the stack with context using sourcesContent', async function () {
+    await throwInScriptFile('../examples/node-dist/index.js');
+
+    expect(addItemStub.called).to.be.true;
+
+    const frame = addItemStub
+      .getCall(0)
+      .args[0].body.trace_chain[0].frames.pop();
+
+    expect(frame.filename).to.include('src/index.ts');
+    expect(frame.lineno).to.equal(10);
+    expect(frame.colno).to.equal(22);
+    expect(frame.code).to.equal(
+      "  var error = <Error> new CustomError('foo');",
+    );
+    expect(frame.context.pre[0]).to.equal('    }');
+    expect(frame.context.pre[1]).to.equal('  }');
+    expect(frame.context.pre[2]).to.equal(
+      '  // TypeScript code snippet will include `<Error>`',
+    );
+    expect(frame.context.post[0]).to.equal('  throw error;');
+    expect(frame.context.post[1]).to.equal('}');
+
+    const sourceMappingURLs =
+      addItemStub.getCall(0).args[0].notifier.diagnostic.node_source_maps
+        .source_mapping_urls;
+    const urls = Object.keys(sourceMappingURLs);
+
+    expect(urls).to.have.lengthOf(1);
+    expect(urls[0]).to.include('index.js');
+    expect(sourceMappingURLs[urls[0]]).to.include('index.js.map');
+  });
+});