rollbar 2.26.3 → 3.0.0-alpha.1

package/test/replay/integration/queue.replayMap.test.js

@@ -0,0 +1,332 @@
+/**
+ * Integration tests for Queue and ReplayMap
+ */
+
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import Queue from '../../../src/queue.js';
+import Api from '../../../src/api.js';
+
+describe('Queue ReplayMap Integration', function () {
+  let queue;
+  let replayMap;
+  let api;
+  let transport;
+
+  beforeEach(function () {
+    transport = {
+      post: sinon
+        .stub()
+        .callsFake((accessToken, transportOptions, payload, callback) => {
+          setTimeout(() => {
+            callback(
+              null,
+              { err: 0, result: { id: '12345' } },
+              { 'Rollbar-Replay-Enabled': 'true' }
+            );
+          }, 10);
+        }),
+      postJsonPayload: sinon.stub(),
+    };
+
+    const urlMock = { parse: sinon.stub().returns({}) };
+    const truncationMock = {
+      truncate: sinon.stub().returns({ error: null, value: '{}' }),
+    };
+
+    api = new Api(
+      { accessToken: 'test-token' },
+      transport,
+      urlMock,
+      truncationMock,
+    );
+
+    replayMap = {
+      add: sinon.stub().returnsArg(0),
+      send: sinon.stub().resolves(true),
+      discard: sinon.stub().returns(true),
+      getSpans: sinon.stub().returns([{ id: 'test-span' }]),
+      setSpans: sinon.stub(),
+    };
+
+    queue = new Queue(
+      { shouldSend: () => ({ shouldSend: true }) },
+      api,
+      console,
+      { transmit: true },
+      replayMap,
+    );
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  it('should add replayId when processing an item', function (done) {
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      expect(item).to.have.property('replayId', '1234567812345678');
+      expect(replayMap.add.calledOnce).to.be.true;
+      done();
+    });
+  });
+
+  it('should call replayMap.send when API response is successful', function (done) {
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      setTimeout(function () {
+        expect(replayMap.send.calledWith('1234567812345678')).to.be.true;
+        done();
+      }, 50);
+    });
+  });
+
+  it('should call replayMap.discard when API response has error', function (done) {
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(null, { err: 1, message: 'API Error' });
+        }, 10);
+      },
+    );
+
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with API failure',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      setTimeout(function () {
+        expect(replayMap.discard.calledWith('1234567812345678')).to.be.true;
+        expect(replayMap.send.called).to.be.false;
+        done();
+      }, 50);
+    });
+  });
+
+  it('should call replayMap.discard when replay is disabled', function (done) {
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(
+            null,
+            { err: 0, result: { id: '12345' } },
+            { 'Rollbar-Replay-Enabled': 'false' }
+          );
+        }, 10);
+      },
+    );
+
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with replay disabled',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      setTimeout(function () {
+        expect(replayMap.discard.calledWith('1234567812345678')).to.be.true;
+        expect(replayMap.send.called).to.be.false;
+        done();
+      }, 50);
+    });
+  });
+
+  it('should call replayMap.discard when over quota', function (done) {
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(
+            null,
+            { err: 0, result: { id: '12345' } },
+            { 'Rollbar-Replay-Enabled': 'true',
+              'Rollbar-Replay-RateLimit-Remaining': '0'}
+          );
+        }, 10);
+      },
+    );
+
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with replay over quota',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      setTimeout(function () {
+        expect(replayMap.discard.calledWith('1234567812345678')).to.be.true;
+        expect(replayMap.send.called).to.be.false;
+        done();
+      }, 50);
+    });
+  });
+
+  it('should handle retrying items with replayId', function (done) {
+    let apiCallCount = 0;
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        apiCallCount++;
+        if (apiCallCount === 1) {
+          setTimeout(() => {
+            callback({ code: 'ECONNRESET' });
+          }, 10);
+        } else {
+          setTimeout(() => {
+            callback(
+              null,
+              { err: 0, result: { id: '12345' } },
+              { 'Rollbar-Replay-Enabled': 'true' }
+            );
+          }, 10);
+        }
+      },
+    );
+
+    queue.configure({ retryInterval: 50, maxRetries: 3 });
+
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with retry',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function (err, resp) {
+      if (resp) {
+        expect(item).to.have.property('replayId', '1234567812345678');
+
+        setTimeout(function () {
+          expect(replayMap.send.calledWith('1234567812345678')).to.be.true;
+          done();
+        }, 50);
+      }
+    });
+  });
+
+  it('should not add replayId to items without a body', function (done) {
+    const item = {
+      level: 'error',
+      message: 'Test error without body',
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      expect(item).to.not.have.property('replayId');
+      expect(replayMap.add.called).to.be.false;
+      done();
+    });
+  });
+
+  it('should not add replayId to items without a replay_id attribute', function (done) {
+    const item = {
+      level: 'error',
+      message: 'Test error without body',
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with retry',
+          },
+        },
+      },
+    };
+
+    queue.addItem(item, function () {
+      expect(item).to.not.have.property('replayId');
+      expect(replayMap.add.called).to.be.false;
+      done();
+    });
+  });
+
+  it('should handle null response in _handleReplayResponse', function (done) {
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(null, null);
+        }, 10);
+      },
+    );
+
+    const consoleWarnSpy = sinon.spy(console, 'warn');
+
+    const item = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with null response',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(item, function () {
+      setTimeout(function () {
+        expect(replayMap.send.called).to.be.false;
+        expect(replayMap.discard.calledWith('1234567812345678')).to.be.false;
+        done();
+      }, 50);
+    });
+  });
+});

package/test/replay/integration/replayMap.test.js

@@ -0,0 +1,163 @@
+/**
+ * Integration tests for ReplayMap with API
+ */
+
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import ReplayMap from '../../../src/browser/replay/replayMap.js';
+import Recorder from '../../../src/browser/replay/recorder.js';
+import Tracing from '../../../src/tracing/tracing.js';
+import Api from '../../../src/api.js';
+import { mockRecordFn } from '../util';
+
+const options = {
+  enabled: true,
+  recorder: {
+    enabled: true,
+    emitEveryNms: 100,
+  },
+};
+
+describe('ReplayMap API Integration', function () {
+  let tracing;
+  let recorder;
+  let api;
+  let transport;
+  let replayMap;
+
+  beforeEach(function () {
+    transport = {
+      post: sinon
+        .stub()
+        .callsFake((accessToken, transportOptions, payload, callback) => {
+          setTimeout(() => {
+            callback(
+              null,
+              { err: 0, result: { id: '12345' } },
+              { 'Rollbar-Replay-Enabled': 'true' }
+            );
+          }, 10);
+        }),
+      postJsonPayload: sinon.stub(),
+    };
+
+    const urlMock = { parse: sinon.stub().returns({}) };
+    const truncationMock = {
+      truncate: sinon.stub().returns({ error: null, value: '{}' }),
+    };
+
+    tracing = new Tracing(window, options);
+    tracing.initSession();
+
+    const mockPayload = [{ id: 'span1', name: 'recording-span' }];
+
+    api = new Api(
+      { accessToken: 'test-token' },
+      transport,
+      urlMock,
+      truncationMock,
+    );
+
+    recorder = new Recorder(options.recorder, mockRecordFn);
+    sinon.stub(recorder, 'dump').returns(mockPayload);
+
+    replayMap = new ReplayMap({
+      recorder,
+      api,
+      tracing,
+    });
+
+    recorder.start();
+  });
+
+  afterEach(function () {
+    if (recorder) {
+      recorder.stop();
+    }
+    sinon.restore();
+  });
+
+  it('should add replay data to map', async function () {
+    const uuid = 'test-uuid';
+    const replayId = replayMap.add(null, uuid);
+    expect(replayId).to.be.a('string');
+    expect(replayId.length).to.equal(16); // 8 bytes as hex = 16 characters
+
+    await new Promise((r) => setTimeout(r, 1000));
+
+    expect(recorder.dump.calledOnce).to.be.true;
+    expect(recorder.dump.calledWith(tracing, replayId, uuid)).to.be.true;
+
+    const payload = replayMap.getSpans(replayId);
+    expect(payload).to.not.be.null;
+    expect(payload).to.be.an('array');
+    expect(payload[0]).to.have.property('name', 'recording-span');
+  });
+
+  it('should successfully send replay to API', async function () {
+    const postSpansSpy = sinon.spy(api, 'postSpans');
+
+    const replayId = 'test-replay-id';
+    const mockPayload = [{ id: 'test-span', name: 'recording-span' }];
+    replayMap.setSpans(replayId, mockPayload);
+
+    const result = await replayMap.send(replayId);
+
+    expect(result).to.be.true;
+    expect(postSpansSpy.calledOnce).to.be.true;
+    expect(postSpansSpy.calledWith(mockPayload)).to.be.true;
+
+    expect(replayMap.getSpans(replayId)).to.be.null;
+  });
+
+  it('should handle API errors during send', async function () {
+    const apiError = new Error('API failure');
+    sinon.stub(api, 'postSpans').rejects(apiError);
+
+    const consoleSpy = sinon.spy(console, 'error');
+
+    const replayId = 'error-replay-id';
+    const mockPayload = [{ id: 'test-span', name: 'recording-span' }];
+    replayMap.setSpans(replayId, mockPayload);
+
+    const result = await replayMap.send(replayId);
+
+    expect(result).to.be.false;
+    expect(replayMap.getSpans(replayId)).to.be.null;
+  });
+
+  it('should discard replay without sending', function () {
+    const postSpansSpy = sinon.spy(api, 'postSpans');
+
+    const replayId = 'discard-replay-id';
+    const mockPayload = [{ id: 'test-span', name: 'recording-span' }];
+    replayMap.setSpans(replayId, mockPayload);
+
+    const result = replayMap.discard(replayId);
+
+    expect(result).to.be.true;
+    expect(postSpansSpy.called).to.be.false;
+
+    expect(replayMap.getSpans(replayId)).to.be.null;
+  });
+
+  it('should generate unique replay IDs', function () {
+    const replayIds = new Set();
+
+    sinon.stub(replayMap, '_processReplay').resolves();
+
+    for (let i = 0; i < 100; i++) {
+      const replayId = replayMap.add();
+      expect(replayIds.has(replayId)).to.be.false;
+      replayIds.add(replayId);
+    }
+
+    expect(replayIds.size).to.equal(100);
+  });
+});