rollbar 2.26.3 → 3.0.0-alpha.1

package/test/react-native.transforms.test.js

@@ -3,20 +3,20 @@
 /* globals it */
 /* globals sinon */
 
-var Rollbar = require('../src/react-native/rollbar');
-var t = require('../src/react-native/transforms');
+import Rollbar from '../src/react-native/rollbar.js';
+import t from '../src/react-native/transforms.js';
 
 function TestClientGen() {
-  var TestClient = function() {
+  var TestClient = function () {
     this.notifier = {
-      addTransform: function() {
+      addTransform: function () {
         return this.notifier;
-      }.bind(this)
+      }.bind(this),
     };
     this.queue = {
-      addPredicate: function() {
+      addPredicate: function () {
         return this.queue;
-      }.bind(this)
+      }.bind(this),
     };
   };
   return TestClient;
@@ -24,47 +24,45 @@ function TestClientGen() {
 
 function itemFromArgs(args) {
   var client = new (TestClientGen())();
-  var rollbar = new Rollbar({autoInstrument: false}, client);
+  var rollbar = new Rollbar({ autoInstrument: false }, client);
   var item = rollbar._createItem(args);
   item.level = 'debug';
   return item;
 }
 
-describe('handleItemWithError', function() {
-  it('should create stackInfo', function(done) {
+describe('handleItemWithError', function () {
+  it('should create stackInfo', function (done) {
     var err = new Error('test');
     var args = ['a message', err];
     var item = itemFromArgs(args);
-    var options = (new Rollbar({})).options;
-    t.handleItemWithError(item, options, function(e, i) {
-      expect(item.stackInfo.exception).to.eql({class: 'Error', message: 'test'});
+    var options = new Rollbar({}).options;
+    t.handleItemWithError(item, options, function (e, i) {
+      expect(item.stackInfo.exception).to.eql({
+        class: 'Error',
+        message: 'test',
+      });
       done(e);
     });
   });
 });
-describe('_matchFilename', function() {
+describe('_matchFilename', function () {
   var filenames = {
     before: [
       '/var/mobile/Containers/Data/Application/1122ABCD-FF02-4942-A0D7-632E691D342F/.app/main.jsbundle',
       '/var/mobile/Containers/Data/Application/1122ABCD-FF02-4942-A0D7-632E691D342F/Library/Application Support/CodePush/2071980d74d1fef682fdab1d1cab345f33f498e3b51f68585c1b0b5469334df7/codepush_ios/main.jsbundle',
       '/data/user/0/com.example/files/CodePush/2071980d74d1fef682fdab1d1cab345f33f498e3b51f68585c1b0b5469334df7/codepush_android/index.android.bundle',
-      'index.android.bundle'
-    ],
-    after: [
-      'main.jsbundle',
-      'main.jsbundle',
       'index.android.bundle',
-      null
-    ]
-  }
+    ],
+    after: ['main.jsbundle', 'main.jsbundle', 'index.android.bundle', null],
+  };
 
-  it('should rewrite filenames', function(done) {
-    var options = (new Rollbar({})).options;
+  it('should rewrite filenames', function (done) {
+    var options = new Rollbar({}).options;
     console.log(options);
 
     var length = filenames.before.length;
 
-    for(var i = 0; i < length; i++){
+    for (var i = 0; i < length; i++) {
       var filename = t._matchFilename(filenames.before[i], options);
       expect(filename).to.eql(filenames.after[i]);
     }

package/test/react-native.transport.test.js

@@ -3,22 +3,22 @@
 /* globals it */
 /* globals sinon */
 
-var truncation = require('../src/truncation');
-var Transport = require('../src/react-native/transport');
+import truncation from '../src/truncation.js';
+import Transport from '../src/react-native/transport.js';
 var t = new Transport(truncation);
-var utility = require('../src/utility');
+import utility from '../src/utility.js';
 utility.setupJSON();
 
-describe('post', function() {
+describe('post', function () {
   var accessToken = 'abc123';
   var options = {
     hostname: 'api.rollbar.com',
     protocol: 'https',
-    path: '/api/1/item/'
+    path: '/api/1/item/',
   };
   var payload = {
     access_token: accessToken,
-    data: {a: 1}
+    data: { a: 1 },
   };
   var uuid = 'd4c7acef55bf4c9ea95e4fe9428a8287';
 
@@ -33,16 +33,28 @@ describe('post', function() {
   });
 
   function stubResponse(code, err, message) {
-    window.fetch.returns(Promise.resolve(new Response(
-      JSON.stringify({ err: err, message: message, result: { uuid: uuid }}),
-      { status: code, statusText: message, headers: { 'Content-Type': 'application/json' }}
-    )));
+    window.fetch.returns(
+      Promise.resolve(
+        new Response(
+          JSON.stringify({
+            err: err,
+            message: message,
+            result: { uuid: uuid },
+          }),
+          {
+            status: code,
+            statusText: message,
+            headers: { 'Content-Type': 'application/json' },
+          },
+        ),
+      ),
+    );
   }
 
-  it('should callback with the right value on success', function(done) {
+  it('should callback with the right value on success', function (done) {
     stubResponse(200, 0, 'OK');
 
-    var callback = function(err, data) {
+    var callback = function (err, data) {
       expect(err).to.eql(null);
       expect(data).to.be.ok();
       expect(data.uuid).to.eql(uuid);
@@ -51,10 +63,10 @@ describe('post', function() {
     t.post(accessToken, options, payload, callback);
   });
 
-  it('should callback with the server error if 403', function(done) {
+  it('should callback with the server error if 403', function (done) {
     stubResponse(403, '403', 'bad request');
 
-    var callback = function(err, resp) {
+    var callback = function (err, resp) {
       expect(resp).to.not.be.ok();
       expect(err.message).to.eql('Api error: bad request');
       done();

package/test/replay/index.js

@@ -0,0 +1,2 @@
+export * from './integration/index.js';
+export * from './unit/index.js';

package/test/replay/integration/api.spans.test.js

@@ -0,0 +1,136 @@
+/**
+ * API integration tests for span transport
+ */
+
+/* globals describe */
+/* globals it */
+/* globals beforeEach */
+/* globals afterEach */
+
+import { expect } from 'chai';
+import sinon from 'sinon';
+
+import Api from '../../../src/api.js';
+import {
+  standardPayload,
+  createPayloadWithReplayId,
+} from '../../fixtures/replay/payloads.fixtures.js';
+
+describe('API Span Transport', function () {
+  let api;
+  let transport;
+  let accessToken;
+
+  beforeEach(function () {
+    accessToken = 'test-token-12345';
+
+    transport = {
+      post: sinon
+        .stub()
+        .callsFake((accessToken, transportOptions, payload, callback) => {
+          setTimeout(() => {
+            callback(null, { err: 0, result: { id: '12345' } });
+          }, 10);
+        }),
+      postJsonPayload: sinon.stub(),
+    };
+
+    const urlMock = { parse: sinon.stub().returns({}) };
+    const truncationMock = {
+      truncate: sinon.stub().returns({ error: null, value: '{}' }),
+    };
+
+    api = new Api({ accessToken }, transport, urlMock, truncationMock);
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  it('should use the session endpoint for spans', async function () {
+    const spans = standardPayload;
+
+    await api.postSpans(spans);
+
+    expect(transport.post.calledOnce).to.be.true;
+
+    const transportOptions = transport.post.firstCall.args[1];
+    expect(transportOptions.path).to.include('/api/1/session/');
+  });
+
+  it('should format spans payload correctly', async function () {
+    const testReplayId = 'test-replay-api-12345';
+    const spans = createPayloadWithReplayId(testReplayId);
+
+    await api.postSpans(spans);
+
+    const payload = transport.post.firstCall.args[2];
+
+    expect(payload).to.have.property('resourceSpans');
+    expect(payload).to.deep.equal(spans);
+  });
+
+  it('should handle transport errors', async function () {
+    const testError = new Error('Transport failure');
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(testError);
+        }, 10);
+      },
+    );
+
+    const spans = [{ id: 'error-span', name: 'error-recording' }];
+
+    try {
+      await api.postSpans(spans);
+      expect.fail('Expected error not thrown');
+    } catch (error) {
+      expect(error).to.equal(testError);
+    }
+  });
+
+  it('should handle API response errors', async function () {
+    transport.post.callsFake(
+      (accessToken, transportOptions, payload, callback) => {
+        setTimeout(() => {
+          callback(null, { err: 1, message: 'API Error' });
+        }, 10);
+      },
+    );
+
+    const spans = [{ id: 'error-span', name: 'error-recording' }];
+
+    const response = await api.postSpans(spans);
+
+    expect(response).to.have.property('err', 1);
+    expect(response).to.have.property('message', 'API Error');
+  });
+
+  it('should merge options when reconfigured', function () {
+    const originalOptions = api.options;
+
+    api.configure({
+      endpoint: 'https://custom.rollbar.com/api/',
+    });
+
+    expect(api.options).to.not.equal(originalOptions);
+    expect(api.options).to.have.property(
+      'endpoint',
+      'https://custom.rollbar.com/api/',
+    );
+    expect(api.accessToken).to.equal(accessToken);
+  });
+
+  it('should update sessionTransportOptions when reconfigured', function () {
+    const originalTransportOptions = api.OTLPTransportOptions;
+
+    api.configure({
+      tracing: {
+        endpoint: 'https://custom.rollbar.com/api/',
+      },
+    });
+
+    expect(api.OTLPTransportOptions).to.not.equal(originalTransportOptions);
+  });
+});

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';