rollbar 2.26.4 → 3.0.0-alpha.2

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

package/test/replay/integration/sessionRecording.test.js

@@ -0,0 +1,390 @@
+/**
+ * Integration tests for the Recorder and Tracing interaction
+ */
+
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import Tracing from '../../../src/tracing/tracing.js';
+import { Context } from '../../../src/tracing/context.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 { mockRecordFn } from '../util';
+import Api from '../../../src/api.js';
+import Queue from '../../../src/queue.js';
+import { createPayloadWithReplayId } from '../../fixtures/replay';
+
+const options = {
+  enabled: true,
+  resource: {
+    attributes: {
+      'service.name': 'unknown_service',
+      'telemetry.sdk.language': 'webjs',
+      'telemetry.sdk.name': 'rollbar',
+      'telemetry.sdk.version': '0.1.0',
+    },
+  },
+  notifier: {
+    name: 'rollbar.js',
+    version: '0.1.0',
+  },
+  recorder: {
+    ...recorderDefaults,
+    enabled: true,
+    autoStart: false,
+    emitEveryNms: 100, // non-rrweb, used by mockRecordFn
+  },
+};
+
+const createMockTransport = () => {
+  return {
+    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 getAttributeValue = (attributes, key) => {
+  const attr = attributes.find((attr) => attr.key === key);
+  return attr ? attr.value : null;
+};
+
+describe('Session Replay Integration', function () {
+  let tracing;
+  let recorder;
+
+  beforeEach(function () {
+    tracing = new Tracing(window, options);
+    tracing.initSession();
+  });
+
+  afterEach(function () {
+    if (recorder) {
+      recorder.stop();
+    }
+    sinon.restore();
+  });
+
+  it('dumping recording should export tracing', function (done) {
+    recorder = new Recorder(options.recorder, mockRecordFn);
+    recorder.start();
+
+    const tracingContext = tracing.contextManager.active();
+    expect(tracingContext).to.be.instanceOf(Context);
+
+    const dumpRecording = () => {
+      const replayId = 'test-replay-id';
+      const uuid = 'test-uuid';
+      const payload = recorder.dump(tracing, replayId, uuid);
+
+      expect(payload).to.not.be.null;
+      expect(payload).to.be.an('object');
+      expect(payload).to.have.property('resourceSpans');
+      expect(payload.resourceSpans).to.be.an('array');
+      expect(payload.resourceSpans[0]).to.have.property('scopeSpans');
+      expect(payload.resourceSpans[0].scopeSpans[0]).to.have.property('spans');
+
+      const uuidValue = getAttributeValue(
+        payload.resourceSpans[0].scopeSpans[0].spans[0].attributes,
+        'rollbar.occurrence.uuid',
+      );
+      expect(uuidValue['stringValue']).to.equal(uuid);
+
+      const events = payload.resourceSpans[0].scopeSpans[0].spans[0].events;
+      expect(events.length).to.be.greaterThan(0);
+      expect(events.every((e) => e.name === 'rrweb-replay-events')).to.be.true;
+
+      const eventAttrs = events[0].attributes;
+      const eventTypeAttr = eventAttrs.find((attr) => attr.key === 'eventType');
+      const jsonAttr = eventAttrs.find((attr) => attr.key === 'json');
+
+      expect(eventTypeAttr).to.exist;
+      expect(jsonAttr).to.exist;
+
+      done();
+    };
+
+    setTimeout(dumpRecording, 1000);
+  });
+
+  it('should handle checkouts correctly', function (done) {
+    recorder = new Recorder(
+      {
+        ...options.recorder,
+        checkoutEveryNms: 250,
+      },
+      mockRecordFn,
+    );
+
+    recorder.start();
+
+    const dumpRecording = () => {
+      const replayId = 'test-replay-id';
+      const payload = recorder.dump(tracing, replayId);
+
+      expect(payload).to.not.be.null;
+      expect(payload).to.be.an('object');
+      expect(payload).to.have.property('resourceSpans');
+      expect(payload.resourceSpans).to.be.an('array');
+      expect(payload.resourceSpans[0]).to.have.property('scopeSpans');
+      expect(payload.resourceSpans[0].scopeSpans[0]).to.have.property('spans');
+
+      const events = payload.resourceSpans[0].scopeSpans[0].spans[0].events;
+      expect(events).to.be.an('array');
+      expect(events.length).to.be.greaterThan(0);
+
+      done();
+    };
+
+    setTimeout(dumpRecording, 1000);
+  });
+
+  it('should handle no checkouts correctly', function (done) {
+    recorder = new Recorder(
+      {
+        ...options.recorder,
+        checkoutEveryNms: 500,
+      },
+      mockRecordFn,
+    );
+
+    recorder.start();
+
+    const dumpRecording = () => {
+      const replayId = 'test-replay-id';
+      const payload = recorder.dump(tracing, replayId);
+
+      expect(payload).to.not.be.null;
+      expect(payload).to.be.an('object');
+      expect(payload).to.have.property('resourceSpans');
+      expect(payload.resourceSpans).to.be.an('array');
+      expect(payload.resourceSpans[0]).to.have.property('scopeSpans');
+      expect(payload.resourceSpans[0].scopeSpans[0]).to.have.property('spans');
+
+      const events = payload.resourceSpans[0].scopeSpans[0].spans[0].events;
+      expect(events).to.be.an('array');
+      expect(events.length).to.be.greaterThan(0);
+
+      done();
+    };
+
+    setTimeout(dumpRecording, 250);
+  });
+});
+
+describe('Session Replay Transport Integration', function () {
+  let tracing;
+  let recorder;
+  let api;
+  let transport;
+  let replayMap;
+  let queue;
+
+  beforeEach(function () {
+    transport = createMockTransport();
+    const urlMock = { parse: sinon.stub().returns({}) };
+    const truncationMock = {
+      truncate: sinon.stub().returns({ error: null, value: '{}' }),
+    };
+
+    tracing = new Tracing(window, options);
+    tracing.initSession();
+
+    api = new Api(
+      { accessToken: 'test-token' },
+      transport,
+      urlMock,
+      truncationMock,
+    );
+
+    recorder = new Recorder(options.recorder, mockRecordFn);
+
+    sinon.stub(recorder, 'dump').callsFake((tracing, replayId) => {
+      return createPayloadWithReplayId(replayId);
+    });
+
+    replayMap = new ReplayMap({
+      recorder,
+      api,
+      tracing,
+    });
+
+    queue = new Queue(
+      { shouldSend: () => ({ shouldSend: true }) },
+      api,
+      console,
+      { transmit: true, retryInterval: 500 },
+      replayMap,
+    );
+
+    recorder.start();
+  });
+
+  afterEach(function () {
+    if (recorder) {
+      recorder.stop();
+    }
+    sinon.restore();
+  });
+
+  it('should add replayId to error item and send replay on success', function (done) {
+    const addSpy = sinon.spy(replayMap, 'add');
+    const sendSpy = sinon.spy(replayMap, 'send');
+    const postSpansSpy = sinon.spy(api, 'postSpans');
+
+    const errorItem = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error for session replay',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(errorItem, function (err, resp) {
+      expect(errorItem).to.have.property('replayId');
+      expect(addSpy.calledOnce).to.be.true;
+
+      expect(err).to.be.null;
+      expect(resp).to.have.property('err', 0);
+
+      setTimeout(function () {
+        expect(sendSpy.calledWith(errorItem.replayId)).to.be.true;
+        expect(postSpansSpy.calledOnce).to.be.true;
+
+        done();
+      }, 50);
+    });
+  });
+
+  it('should discard replay when API returns an error', function (done) {
+    transport.post = sinon
+      .stub()
+      .callsFake((accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(null, { err: 1, message: 'API Error' });
+        }, 10);
+      });
+
+    const addSpy = sinon.spy(replayMap, 'add');
+    const sendSpy = sinon.spy(replayMap, 'send');
+    const discardSpy = sinon.spy(replayMap, 'discard');
+
+    const errorItem = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test error with API failure',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queue.addItem(errorItem, function (err, resp) {
+      expect(errorItem).to.have.property('replayId');
+      expect(addSpy.calledOnce).to.be.true;
+
+      setTimeout(function () {
+        expect(discardSpy.calledWith(errorItem.replayId)).to.be.true;
+        expect(sendSpy.called).to.be.false;
+
+        done();
+      }, 50);
+    });
+  });
+
+  it('should handle full end-to-end flow from error to spans', async function () {
+    const addSpy = sinon.spy(replayMap, 'add');
+    const sendSpy = sinon.spy(replayMap, 'send');
+    const postSpansSpy = sinon.spy(api, 'postSpans');
+
+    const handleReplayResponseSpy = sinon.spy(queue, '_handleReplayResponse');
+
+    const errorItem = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test E2E flow',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    const addItemPromise = new Promise((resolve, reject) => {
+      queue.addItem(errorItem, (err, resp) => {
+        if (err) reject(err);
+        else resolve(resp);
+      });
+    });
+
+    await addItemPromise;
+    expect(errorItem).to.have.property('replayId');
+    expect(addSpy.calledOnce).to.be.true;
+
+    const responsePromise = handleReplayResponseSpy.returnValues[0];
+    await responsePromise;
+    expect(sendSpy.calledOnce).to.be.true;
+    expect(sendSpy.calledWith(errorItem.replayId)).to.be.true;
+    expect(postSpansSpy.calledOnce).to.be.true;
+
+    expect(recorder.dump.called).to.be.true;
+    expect(recorder.dump.calledWith(tracing, errorItem.replayId)).to.be.true;
+    const callArgs = postSpansSpy.firstCall.args;
+    expect(callArgs[0]).to.be.an('object');
+    expect(callArgs[0].resourceSpans[0].scopeSpans[0].spans[0].name).to.equal(
+      'rrweb-replay-recording',
+    );
+  });
+
+  it('should not add replayId when replayMap is not provided', function (done) {
+    const queueWithoutReplayMap = new Queue(
+      { shouldSend: () => ({ shouldSend: true }) },
+      api,
+      console,
+      { transmit: true },
+    );
+
+    const errorItem = {
+      body: {
+        trace: {
+          exception: {
+            message: 'Test without replayMap',
+          },
+        },
+      },
+      attributes: [
+        { key: 'replay_id', value: '1234567812345678' },
+      ],
+    };
+
+    queueWithoutReplayMap.addItem(errorItem, function (err, resp) {
+      expect(errorItem).to.not.have.property('replayId');
+      done();
+    });
+  });
+});

package/test/replay/unit/api.postSpans.test.js

@@ -0,0 +1,150 @@
+/**
+ * Unit tests for the postSpans method in the API module
+ */
+
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+/* globals sinon */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+const Api = require('../../../src/api');
+
+describe('Api', function () {
+  let api;
+  let transport;
+  let mockUrl;
+
+  beforeEach(function () {
+    transport = {
+      post: sinon
+        .stub()
+        .callsFake((accessToken, options, payload, callback) => {
+          callback(null, { result: 'ok' });
+        }),
+      postJsonPayload: sinon.stub(),
+    };
+
+    mockUrl = {
+      parse: sinon.stub().returns({
+        hostname: 'api.rollbar.com',
+        protocol: 'https:',
+        port: 443,
+        pathname: '/api/1/item/',
+        search: null,
+      }),
+    };
+
+    api = new Api(
+      { accessToken: 'test_token' },
+      transport,
+      mockUrl,
+      null, // truncation
+    );
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  describe('postSpans', function () {
+    it('should create proper transport options for session endpoint', async function () {
+      const spans = [{ id: 'span1' }];
+      await api.postSpans(spans);
+
+      expect(transport.post.called).to.be.true;
+
+      const options = transport.post.firstCall.args[1];
+      expect(options.path).to.include('/session/');
+      expect(options.method).to.equal('POST');
+    });
+
+    it('should create a payload with resourceSpans', async function () {
+      const spans = { resourceSpans: [{ id: 'span1' }] };
+      await api.postSpans(spans);
+
+      expect(transport.post.called).to.be.true;
+
+      const payload = transport.post.firstCall.args[2];
+      expect(payload).to.have.property('resourceSpans');
+      expect(payload).to.deep.equal(spans);
+    });
+
+    it('should return a promise that resolves with the response', async function () {
+      const spans = [{ id: 'span1' }];
+      const expectedResponse = { result: 'ok' };
+
+      const result = await api.postSpans(spans);
+      expect(result).to.deep.equal(expectedResponse);
+    });
+
+    it('should handle transport errors', async function () {
+      const spans = [{ id: 'span1' }];
+      const expectedError = new Error('Transport error');
+
+      transport.post.callsFake((accessToken, options, payload, callback) => {
+        callback(expectedError);
+      });
+
+      try {
+        await api.postSpans(spans);
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).to.equal(expectedError);
+      }
+    });
+
+    it('should use the provided access token', async function () {
+      const spans = [{ id: 'span1' }];
+      await api.postSpans(spans);
+
+      expect(transport.post.called).to.be.true;
+      const accessToken = transport.post.firstCall.args[0];
+      expect(accessToken).to.equal('test_token');
+    });
+
+    it('should update transport options when API is reconfigured', async function () {
+      await api.postSpans([{ id: 'span1' }]);
+
+      api.configure({
+        endpoint: 'https://custom.rollbar.com/api/1/session/',
+      });
+
+      await api.postSpans([{ id: 'span2' }]);
+
+      expect(transport.post.callCount).to.equal(2);
+
+      const optionsAfterConfig = transport.post.secondCall.args[1];
+      expect(optionsAfterConfig.hostname).to.equal('api.rollbar.com');
+    });
+  });
+
+  describe('_postPromise', function () {
+    it('should resolve with response when transport succeeds', async function () {
+      const expectedResponse = { success: true };
+      transport.post.callsFake((accessToken, options, payload, callback) => {
+        callback(null, expectedResponse);
+      });
+
+      const result = await api._postPromise('token', {}, {});
+      expect(result).to.deep.equal(expectedResponse);
+    });
+
+    it('should reject with error when transport fails', async function () {
+      const expectedError = new Error('Transport error');
+      transport.post.callsFake((accessToken, options, payload, callback) => {
+        callback(expectedError);
+      });
+
+      try {
+        await api._postPromise('token', {}, {});
+        expect.fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).to.equal(expectedError);
+      }
+    });
+  });
+});

package/test/replay/unit/index.js

@@ -0,0 +1,7 @@
+/**
+ * Session Replay Unit Tests
+ */
+
+export * from './replayMap.test.js';
+export * from './api.postSpans.test.js';
+export * from './queue.replayMap.test.js';