rollbar 2.26.4 → 3.0.0-alpha.2

package/test/replay/integration/e2e.test.js

@@ -0,0 +1,228 @@
+/**
+ * End-to-end integration test for the complete session replay feature
+ */
+
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import Tracing from '../../../src/tracing/tracing.js';
+import Recorder from '../../../src/browser/replay/recorder.js';
+import ReplayMap from '../../../src/browser/replay/replayMap.js';
+import recorderDefaults from '../../../src/browser/replay/defaults.js';
+import Api from '../../../src/api.js';
+import Queue from '../../../src/queue.js';
+import { mockRecordFn } from '../util';
+import * as payloads from '../../fixtures/replay/payloads.fixtures.js';
+
+const options = {
+  enabled: true,
+  resource: {
+    'service.name': 'test_service',
+  },
+  notifier: {
+    name: 'rollbar.js',
+    version: '0.1.0',
+  },
+  recorder: {
+    ...recorderDefaults,
+    enabled: true,
+    autoStart: true,
+    emitEveryNms: 50,
+  },
+  payload: {
+    environment: 'testenv',
+  },
+};
+
+describe('Session Replay E2E', function () {
+  let tracing;
+  let recorder;
+  let api;
+  let transport;
+  let replayMap;
+  let queue;
+  let rateLimiter;
+
+  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: '{}' }),
+    };
+    const logger = { error: sinon.spy(), log: sinon.spy() };
+
+    tracing = new Tracing(window, options);
+    tracing.initSession();
+    api = new Api(
+      { accessToken: 'test-token-12345' },
+      transport,
+      urlMock,
+      truncationMock,
+    );
+
+    recorder = new Recorder(options.recorder, mockRecordFn);
+
+    rateLimiter = { shouldSend: () => ({ shouldSend: true }) };
+
+    replayMap = new ReplayMap({
+      recorder,
+      api,
+      tracing,
+    });
+
+    queue = new Queue(rateLimiter, api, logger, { transmit: true }, replayMap);
+  });
+
+  afterEach(function () {
+    if (recorder && recorder.isRecording) {
+      recorder.stop();
+    }
+    sinon.restore();
+  });
+
+  it('should handle complete session replay flow from error to API call', function (done) {
+    recorder.start();
+
+    setTimeout(() => {
+      const recorderDumpSpy = sinon.spy(recorder, 'dump');
+      const replayMapAddSpy = sinon.spy(replayMap, 'add');
+      const replayMapSendSpy = sinon.spy(replayMap, 'send');
+      const apiPostItemSpy = sinon.spy(api, 'postItem');
+      const apiPostSpansSpy = sinon.spy(api, 'postSpans');
+
+      const errorItem = {
+        body: {
+          trace: {
+            exception: {
+              message: 'E2E test error',
+            },
+          },
+        },
+        attributes: [
+          { key: 'replay_id', value: '1234567812345678' },
+        ],
+      };
+
+      queue.addItem(errorItem, function (err, resp) {
+        expect(errorItem).to.have.property('replayId');
+        const expectedReplayId = errorItem.replayId;
+        expect(expectedReplayId).to.match(/^[0-9a-fA-F]{16}$/);
+
+        expect(replayMapAddSpy.calledOnce).to.be.true;
+        expect(apiPostItemSpy.calledOnce).to.be.true;
+
+        setTimeout(() => {
+          expect(recorderDumpSpy.called).to.be.true;
+          expect(recorderDumpSpy.calledWith(tracing, errorItem.replayId)).to.be
+            .true;
+          expect(replayMapSendSpy.calledWith(errorItem.replayId)).to.be.true;
+          expect(apiPostSpansSpy.calledOnce).to.be.true;
+
+          const payload = apiPostSpansSpy.firstCall.args[0];
+          expect(payload).to.be.an('object');
+          expect(payload).to.have.property('resourceSpans');
+          expect(payload.resourceSpans).to.be.an('array');
+          expect(payload.resourceSpans).to.have.length.greaterThan(0);
+
+          const resourceSpan = payload.resourceSpans[0];
+          expect(resourceSpan).to.have.property('resource');
+
+          const resource = payload.resourceSpans[0].resource;
+          expect(resource).to.deep.equal(
+            payloads.standardPayload.resourceSpans[0].resource,
+          );
+
+          const span = resourceSpan.scopeSpans[0].spans[0];
+          expect(span).to.have.property('name', 'rrweb-replay-recording');
+          expect(span).to.have.property('events');
+          expect(span.events).to.be.an('array');
+          expect(span).to.have.property('attributes').that.is.an('array');
+          expect(span.attributes).to.have.lengthOf(2);
+
+          expect(span.attributes).to.deep.include({
+            key: 'rollbar.replay.id',
+            value: { stringValue: expectedReplayId },
+          });
+
+          const sessionIdAttr = span.attributes.find(
+            (attr) => attr.key === 'session.id',
+          );
+          expect(sessionIdAttr).to.exist;
+          expect(sessionIdAttr.value.stringValue).to.match(/^[0-9a-fA-F]{32}$/);
+
+          const transportArgs = transport.post.lastCall.args;
+          expect(transportArgs[1].path).to.include('/api/1/session/');
+
+          done();
+        }, 200);
+      });
+    }, 50);
+  });
+
+  it('should integrate with real components in failure scenario', function (done) {
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        if (transportOptions.path.includes('/api/1/item/')) {
+          setTimeout(() => {
+            callback(null, { err: 1, message: 'API Error' });
+          }, 10);
+        } else {
+          setTimeout(() => {
+            callback(null, { err: 0, result: { id: '12345' } });
+          }, 10);
+        }
+      },
+    );
+
+    const replayMapAddSpy = sinon.spy(replayMap, 'add');
+    const replayMapDiscardSpy = sinon.spy(replayMap, 'discard');
+    const apiPostSpansSpy = sinon.spy(api, 'postSpans');
+
+    recorder.start();
+
+    const errorItem = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Error that will fail to send',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(errorItem, function (err, resp) {
+      expect(errorItem).to.have.property('replayId');
+      expect(replayMapAddSpy.calledOnce).to.be.true;
+      expect(resp).to.have.property('err', 1);
+
+      setTimeout(() => {
+        expect(replayMapDiscardSpy.calledWith(errorItem.replayId)).to.be.true;
+        expect(apiPostSpansSpy.called).to.be.false;
+        expect(replayMap.getSpans(errorItem.replayId)).to.be.null;
+
+        done();
+      }, 100);
+    });
+  });
+});

package/test/replay/integration/index.js

@@ -0,0 +1,9 @@
+/**
+ * Session Replay Integration Tests
+ */
+
+export * from './sessionRecording.test.js';
+export * from './api.spans.test.js';
+export * from './replayMap.test.js';
+export * from './queue.replayMap.test.js';
+export * from './e2e.test.js';

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);
+    });
+  });
+});