rollbar 2.26.4 → 3.0.0-alpha.2

package/test/server.lambda.mocha.test.mjs

@@ -0,0 +1,172 @@
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import Rollbar from '../src/server/rollbar.js';
+
+function promisePending(promise, callback) {
+  const testValue = 'test-pending';
+
+  // Detect if a given promise is pending/unfulfilled using the
+  // behavior of Promise.race(), which always returns the first
+  // already resolved promise in the array.
+  Promise.race([promise, Promise.resolve(testValue)])
+    .then(function (value) {
+      if (value === testValue) {
+        return callback(true);
+      } else {
+        return callback(false);
+      }
+    })
+    .catch(function (_error) {
+      return callback(false);
+    });
+}
+
+function fakePostItem(_item, callback) {
+  // 1000ms simulates low API response, and allows testing the state before completion.
+  setTimeout(callback, 1000);
+}
+
+const stubContext = {
+  getRemainingTimeInMillis: () => 2000,
+};
+
+describe('lambda', function () {
+  describe('async handler sends message', function () {
+    let rollbar;
+    let handler;
+    let requestStub;
+    let testPromise;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUncaught: true,
+        captureLambdaTimeouts: false,
+      });
+      const api = rollbar.client.notifier.queue.api;
+      requestStub = sinon.stub(api, 'postItem').callsFake(fakePostItem);
+
+      handler = rollbar.lambdaHandler(async (_event, _context) => {
+        // Testing the condition where the client handler sends a message before exit.
+        // The Rollbar wrapper should send, and should not resolve until the API request
+        // has completed.
+        rollbar.info('lambda test message');
+        return 'done';
+      });
+    });
+
+    afterEach(function () {
+      requestStub.restore();
+    });
+
+    it('invokes handler and receives promise', function () {
+      // rollbar.lambdaHandler should have returned a
+      // handler with the correct signature. (The callback handler is length = 3)
+      expect(handler.length).to.equal(2);
+      expect(handler.name).to.equal('rollbarAsyncLambdaHandler');
+
+      // The rollbar.wait() in the wrapper should prevent this from
+      // resolving until the response is received.
+      testPromise = handler({}, stubContext);
+    });
+
+    it('promise is pending after handler invoked', function (done) {
+      testPromise = handler({}, stubContext);
+
+      // This timeout allows a few extra ticks so that without the wait in
+      // the wrapper this test should fail.
+      setTimeout(function () {
+        promisePending(testPromise, function (pending) {
+          expect(pending).to.be.true;
+          done();
+        });
+      }, 10);
+    });
+
+    it('sends message before exit after promise resolved', function (done) {
+      testPromise = handler({}, stubContext);
+
+      testPromise.then(function (value) {
+        expect(value).to.equal('done');
+
+        // If the handler is allowed to exit prematurely, this will fail.
+        expect(requestStub.called).to.be.true;
+        const data = requestStub.getCall(0).args[0];
+        expect(data.body.message.body).to.equal('lambda test message');
+
+        requestStub.reset();
+        done();
+      });
+    });
+  });
+
+  describe('async handler catches exception', function () {
+    let rollbar;
+    let handler;
+    let requestStub;
+    let testPromise;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUncaught: true,
+        captureLambdaTimeouts: false,
+      });
+      const api = rollbar.client.notifier.queue.api;
+      requestStub = sinon.stub(api, 'postItem').callsFake(fakePostItem);
+
+      handler = rollbar.lambdaHandler(async (_event, _context) => {
+        // Testing the condition where the client handler throws.
+        // The Rollbar wrapper should catch and report, and should not reject
+        // until the API request has completed.
+        throw new Error('lambda test error');
+      });
+    });
+
+    afterEach(function () {
+      requestStub.restore();
+    });
+
+    it('invokes handler and receives promise', function () {
+      // rollbar.lambdaHandler should have returned a
+      // handler with the correct signature. (The callback handler is length = 3)
+      expect(handler.length).to.equal(2);
+      expect(handler.name).to.equal('rollbarAsyncLambdaHandler');
+
+      // The rollbar.wait() in the wrapper should prevent this from
+      // resolving until the response is received.
+      testPromise = handler({}, stubContext);
+    });
+
+    it('promise is pending after handler invoked', function (done) {
+      testPromise = handler({}, stubContext);
+
+      promisePending(testPromise, function (pending) {
+        expect(pending).to.be.true;
+        done();
+      });
+    });
+
+    it('sends message before exit after promise rejected', function (done) {
+      testPromise = handler({}, stubContext);
+
+      testPromise.catch(function (error) {
+        expect(error.message).to.equal('lambda test error');
+
+        // If the handler is allowed to exit prematurely, this will fail.
+        expect(requestStub.called).to.be.true;
+        const data = requestStub.getCall(0).args[0];
+        expect(data.body.trace_chain[0].exception.message).to.equal(
+          'lambda test error',
+        );
+
+        requestStub.reset();
+        done();
+      });
+    });
+  });
+});

package/test/server.locals.constructor.mocha.test.mjs

@@ -0,0 +1,80 @@
+/* globals describe */
+/* globals it */
+
+import { expect } from 'chai';
+import Locals from '../src/server/locals.js';
+import logger from '../src/server/logger.js';
+
+describe('server.locals constructor', function () {
+  it('should use defaults when passing true boolean', function () {
+    const locals = new Locals(true, logger);
+    expect(locals.options.enabled).to.be.true;
+    expect(locals.options.uncaughtOnly).to.be.true;
+    expect(locals.options.depth).to.equal(1);
+    expect(locals.options.maxProperties).to.equal(30);
+    expect(locals.options.maxArray).to.equal(5);
+  });
+
+  it('should use defaults when passing false boolean', function () {
+    const locals = new Locals(false, logger);
+    expect(locals.options.enabled).to.be.true;
+    expect(locals.options.uncaughtOnly).to.be.true;
+    expect(locals.options.depth).to.equal(1);
+    expect(locals.options.maxProperties).to.equal(30);
+    expect(locals.options.maxArray).to.equal(5);
+  });
+
+  it('should use defaults when passing empty object', function () {
+    const locals = new Locals({}, logger);
+    expect(locals.options.enabled).to.be.true;
+    expect(locals.options.uncaughtOnly).to.be.true;
+    expect(locals.options.depth).to.equal(1);
+    expect(locals.options.maxProperties).to.equal(30);
+    expect(locals.options.maxArray).to.equal(5);
+  });
+
+  it('should use updated depth with remaining defaults', function () {
+    const locals = new Locals({ depth: 0 }, logger);
+    expect(locals.options.enabled).to.be.true;
+    expect(locals.options.uncaughtOnly).to.be.true;
+    expect(locals.options.depth).to.equal(0);
+    expect(locals.options.maxProperties).to.equal(30);
+    expect(locals.options.maxArray).to.equal(5);
+  });
+
+  it('should use updated enabled with remaining defaults', function () {
+    const locals = new Locals({ enabled: false }, logger);
+    expect(locals.options.enabled).to.be.false;
+    expect(locals.options.uncaughtOnly).to.be.true;
+    expect(locals.options.depth).to.equal(1);
+    expect(locals.options.maxProperties).to.equal(30);
+    expect(locals.options.maxArray).to.equal(5);
+  });
+
+  it('should use updated uncaughtOnly with remaining defaults', function () {
+    const locals = new Locals({ uncaughtOnly: false }, logger);
+    expect(locals.options.enabled).to.be.true;
+    expect(locals.options.uncaughtOnly).to.be.false;
+    expect(locals.options.depth).to.equal(1);
+    expect(locals.options.maxProperties).to.equal(30);
+    expect(locals.options.maxArray).to.equal(5);
+  });
+
+  it('should use all updated options', function () {
+    const locals = new Locals(
+      {
+        enabled: false,
+        uncaughtOnly: false,
+        depth: 2,
+        maxProperties: 15,
+        maxArray: 10,
+      },
+      logger,
+    );
+    expect(locals.options.enabled).to.be.false;
+    expect(locals.options.uncaughtOnly).to.be.false;
+    expect(locals.options.depth).to.equal(2);
+    expect(locals.options.maxProperties).to.equal(15);
+    expect(locals.options.maxArray).to.equal(10);
+  });
+});

package/test/server.locals.error-handling.mocha.test.mjs

@@ -0,0 +1,387 @@
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+import Rollbar from '../src/server/rollbar.js';
+import Locals from '../src/server/locals.js';
+import {
+  nodeMajorVersion,
+  nodeThrow,
+  nodeThrowNested,
+  nodeThrowAndCatch,
+  promiseReject,
+  nodeThrowWithNestedLocals,
+  nodeThrowRecursionError,
+  verifyRejectedPromise,
+} from './server.locals.test-utils.mjs';
+
+describe('server.locals error handling', function () {
+  let mochaExceptionHandlers;
+  let mochaRejectionHandlers;
+
+  beforeEach(function () {
+    // Remove Mocha's error handlers
+    mochaExceptionHandlers = process.listeners('uncaughtException');
+    mochaExceptionHandlers.forEach((handler) => {
+      process.removeListener('uncaughtException', handler);
+    });
+
+    mochaRejectionHandlers = process.listeners('unhandledRejection');
+    mochaRejectionHandlers.forEach((handler) => {
+      process.removeListener('unhandledRejection', handler);
+    });
+  });
+
+  afterEach(function () {
+    // Restore Mocha's error handlers
+    mochaExceptionHandlers.forEach((h) => process.on('uncaughtException', h));
+    mochaRejectionHandlers.forEach((h) => process.on('unhandledRejection', h));
+  });
+
+  describe('with locals enabled', function () {
+    let rollbar;
+    let addItemStub;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUncaught: true,
+        captureUnhandledRejections: true,
+        locals: { module: Locals, uncaughtOnly: true, depth: 0 },
+      });
+
+      addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+    });
+
+    afterEach(function () {
+      addItemStub.restore();
+    });
+
+    it('should include locals on uncaught error', async function () {
+      await nodeThrow();
+      expect(addItemStub.called).to.be.true;
+
+      const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+      expect(traceChain[0].exception.message).to.equal('node error');
+
+      let frames = traceChain[0].frames;
+      expect(frames).to.have.length.above(1);
+
+      if (nodeMajorVersion >= 18) {
+        // Node >=18; locals only in top frame
+        expect(frames.at(-1).locals.error).to.equal('<Error object>');
+        expect(frames.at(-2).locals).to.not.exist;
+      } else if (nodeMajorVersion >= 10) {
+        // Node >=10; locals enabled
+        expect(frames.at(-1).locals.error).to.equal('<Error object>');
+        expect(frames.at(-2).locals.timer).to.equal('<Timeout object>');
+      } else {
+        // Node <=8; locals disabled
+        expect(frames.at(-1).locals).to.not.exist;
+        expect(frames.at(-2).locals).to.not.exist;
+      }
+    });
+
+    describe('then disabled', function () {
+      beforeEach(function () {
+        addItemStub?.restore();
+        rollbar.configure({ locals: { enabled: false } });
+        addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+      });
+
+      it('should not include locals', async function () {
+        await nodeThrowNested();
+        expect(addItemStub.called).to.be.true;
+
+        const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+        expect(traceChain[0].exception.message).to.equal('test err');
+        expect(traceChain[1].exception.message).to.equal('nested test err');
+
+        expect(traceChain[0].frames).to.have.length.above(1);
+        expect(traceChain[0].frames.at(-1).locals).to.not.exist;
+        expect(traceChain[0].frames.at(-2).locals).to.not.exist;
+      });
+
+      describe('then re-enabled', function () {
+        beforeEach(function () {
+          addItemStub?.restore();
+          rollbar.configure({ locals: { enabled: true, uncaughtOnly: false } });
+          addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+        });
+
+        it('should include locals', async function () {
+          await promiseReject();
+
+          const result = verifyRejectedPromise(addItemStub);
+          expect(result.message).to.equal('promise reject');
+          expect(result.hasLocals).to.be.true;
+          expect(result.locals.topFrame).to.exist;
+        });
+      });
+    });
+  });
+
+  describe('on caught error', function () {
+    describe('with uncaughtOnly: true', function () {
+      let rollbar;
+      let addItemStub;
+
+      beforeEach(function () {
+        rollbar = new Rollbar({
+          accessToken: 'abc123',
+          captureUncaught: true,
+          captureUnhandledRejections: true,
+          locals: { module: Locals, uncaughtOnly: true, depth: 0 },
+        });
+
+        addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+      });
+
+      afterEach(function () {
+        addItemStub.restore();
+      });
+
+      it('should not include locals', async function () {
+        await nodeThrowAndCatch(rollbar);
+        expect(addItemStub.called).to.be.true;
+
+        const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+        expect(traceChain[0].exception.message).to.equal('caught error');
+        expect(traceChain[0].frames).to.have.length.above(1);
+        expect(traceChain[0].frames.at(-1).locals).to.not.exist;
+        expect(traceChain[0].frames.at(-2).locals).to.not.exist;
+      });
+
+      describe('then uncaughtOnly: false', function () {
+        beforeEach(function () {
+          addItemStub?.restore();
+          rollbar.configure({ locals: { uncaughtOnly: false } });
+          addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+        });
+
+        it('should include locals', async function () {
+          await nodeThrowAndCatch(rollbar);
+          expect(addItemStub.called).to.be.true;
+
+          const traceChain =
+            addItemStub.getCall(0).args[3].data.body.trace_chain;
+          expect(traceChain[0].exception.message).to.equal('caught error');
+
+          let frames = traceChain[0].frames;
+          expect(frames).to.have.length.above(1);
+
+          if (nodeMajorVersion >= 18) {
+            // Node >=18; locals only in top frame
+            expect(frames.at(-1).locals.error).to.equal('<Error object>');
+            expect(frames.at(-2).locals).to.not.exist;
+          } else if (nodeMajorVersion >= 10) {
+            // Node 10..<18; locals enabled
+            expect(frames.at(-1).locals.error).to.equal('<Error object>');
+            expect(frames.at(-2).locals.timer).to.equal('<Timeout object>');
+          } else {
+            expect(frames.at(-1).locals).to.not.exist;
+            expect(frames.at(-2).locals).to.not.exist;
+          }
+        });
+      });
+    });
+  });
+
+  describe('on nested exception', function () {
+    let rollbar;
+    let addItemStub;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUncaught: true,
+        locals: { module: Locals, uncaughtOnly: false, depth: 0 },
+      });
+
+      addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+    });
+
+    afterEach(function () {
+      addItemStub.restore();
+    });
+
+    it('should include locals', async function () {
+      await nodeThrowNested();
+      expect(addItemStub.called).to.be.true;
+
+      const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+      expect(traceChain[0].exception.message).to.equal('test err');
+      expect(traceChain[1].exception.message).to.equal('nested test err');
+
+      let frames;
+
+      if (nodeMajorVersion >= 18) {
+        // Node >=18; locals only in top frame
+        frames = traceChain[0].frames;
+        expect(frames).to.have.length.above(1);
+        expect(frames.at(-1).locals.message).to.equal('test err');
+        expect(frames.at(-1).locals.password).to.equal('********');
+        expect(frames.at(-1).locals.err).to.equal('<Error object>');
+        expect(frames.at(-1).locals.newMessage).to.equal('nested test err');
+        expect(frames.at(-2).locals).to.not.exist;
+
+        frames = traceChain[1].frames;
+        expect(frames).to.have.length.above(1);
+        expect(frames.at(-1).locals.nestedMessage).to.equal('nested test err');
+        expect(frames.at(-1).locals._password).to.equal('123456');
+        expect(frames.at(-1).locals.nestedError).to.equal('<Error object>');
+        expect(frames.at(-2).locals).to.not.exist;
+      } else if (nodeMajorVersion >= 10) {
+        // Node >=10; locals enabled
+        frames = traceChain[0].frames;
+        expect(frames).to.have.length.above(1);
+        expect(frames.at(-1).locals.err).to.equal('<Error object>');
+        expect(frames.at(-2).locals.timer).to.equal('<Timeout object>');
+
+        frames = traceChain[1].frames;
+        expect(frames).to.have.length.above(1);
+        expect(frames.at(-1).locals.nestedMessage).to.equal('nested test err');
+        expect(frames.at(-1).locals.nestedError).to.equal('<Error object>');
+        expect(frames.at(-2).locals.message).to.equal('test err');
+        expect(frames.at(-2).locals.password).to.equal('********');
+        expect(frames.at(-2).locals.err).to.equal('<Error object>');
+        expect(frames.at(-2).locals.newMessage).to.equal('nested test err');
+      } else {
+        // Node <=8; locals disabled
+        frames = traceChain[0].frames;
+        expect(frames).to.have.length.above(1);
+        expect(frames.at(-1).locals).to.not.exist;
+        expect(frames.at(-2).locals).to.not.exist;
+      }
+    });
+  });
+
+  describe('on promise rejection', function () {
+    let rollbar;
+    let addItemStub;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUnhandledRejections: true,
+        locals: { module: Locals, uncaughtOnly: false, depth: 0 },
+      });
+
+      addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+    });
+
+    afterEach(function () {
+      addItemStub.restore();
+    });
+
+    it('should include locals', async function () {
+      await promiseReject();
+      const result = verifyRejectedPromise(addItemStub);
+      expect(result.message).to.equal('promise reject');
+    });
+  });
+
+  describe('with custom options', function () {
+    let rollbar;
+    let addItemStub;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUncaught: true,
+        locals: { module: Locals, depth: 2, maxProperties: 5, maxArray: 2 },
+      });
+
+      addItemStub = sinon.stub(rollbar.client.notifier.queue, 'addItem');
+    });
+
+    afterEach(function () {
+      addItemStub.restore();
+      Locals.session = undefined;
+    });
+
+    it('should include locals', async function () {
+      await nodeThrowWithNestedLocals();
+      expect(addItemStub.called).to.be.true;
+
+      const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+      expect(traceChain[0].exception.message).to.equal('node error');
+
+      if (nodeMajorVersion < 10) {
+        // Node 8; locals disabled
+        expect(traceChain[0].frames).to.have.length.above(1);
+        expect(traceChain[0].frames.at(-1).locals).to.not.exist;
+      } else {
+        expect(traceChain[0].frames).to.have.length.above(1);
+
+        const locals = traceChain[0].frames.at(-1).locals;
+        expect(Object.keys(locals.obj)).to.have.lengthOf(5);
+        expect(locals.obj).to.deep.equal({
+          a: 'a',
+          b: 'b',
+          c: 'c',
+          d: 'd',
+          e: 'e',
+        });
+
+        expect(locals.arr).to.have.lengthOf(2);
+        expect(locals.arr[0]).to.deep.equal({ zero: '<Array object>' });
+        expect(locals.arr[1]).to.deep.equal({ one: 1 });
+
+        expect(locals.password).to.equal('********');
+        expect(locals.sym).to.equal('Symbol(foo)');
+      }
+    });
+  });
+
+  describe('with recursive stack', function () {
+    let rollbar;
+    let addItemStub;
+
+    beforeEach(function () {
+      rollbar = new Rollbar({
+        accessToken: 'abc123',
+        captureUncaught: true,
+        locals: Locals,
+      });
+      const notifier = rollbar.client.notifier;
+      addItemStub = sinon.stub(notifier.queue, 'addItem');
+    });
+
+    afterEach(function () {
+      addItemStub.restore();
+      Locals.session = undefined;
+    });
+
+    it('should include locals in recursive frames', async function () {
+      await nodeThrowRecursionError();
+      expect(addItemStub.called).to.be.true;
+
+      const traceChain = addItemStub.getCall(0).args[3].data.body.trace_chain;
+      expect(traceChain[0].exception.message).to.equal(
+        'deep stack error, limit=3',
+      );
+
+      let frames = traceChain[0].frames;
+      expect(frames).to.have.length.above(1);
+
+      if (nodeMajorVersion >= 18) {
+        // Node >=18; locals only in top frame
+        expect(frames.at(-1).locals).to.deep.equal({ curr: 3, limit: 3 });
+        expect(frames.at(-2).locals).to.not.exist;
+        expect(frames.at(-3).locals).to.not.exist;
+      } else if (nodeMajorVersion >= 10) {
+        // Node >=10; locals enabled
+        expect(frames.at(-1).locals).to.deep.equal({ curr: 3, limit: 3 });
+        expect(frames.at(-2).locals).to.deep.equal({ curr: 2, limit: 3 });
+        expect(frames.at(-3).locals).to.deep.equal({ curr: 1, limit: 3 });
+      } else {
+        // Node <=8; locals disabled
+        expect(frames.at(-1).locals).to.not.exist;
+      }
+    });
+  });
+});