@newrelic/browser-agent 1.234.0 → 1.235.0

package/dist/cjs/features/session_replay/aggregate/index.component-test.js

@@ -0,0 +1,457 @@
+"use strict";
+
+var _ = require(".");
+var _aggregator = require("../../../common/aggregate/aggregator");
+var _sessionEntity = require("../../../common/session/session-entity");
+var _config = require("../../../common/config/config");
+var _configure = require("../../../loaders/configure/configure");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+class LocalMemory {
+  constructor() {
+    let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.state = initialState;
+  }
+  get(key) {
+    try {
+      return this.state[key];
+    } catch (err) {
+      return '';
+    }
+  }
+  set(key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key);
+      this.state[key] = value;
+    } catch (err) {
+      return;
+    }
+  }
+  remove(key) {
+    try {
+      delete this.state[key];
+    } catch (err) {
+      return;
+    }
+  }
+}
+let sr, session;
+const agentIdentifier = 'abcd';
+const info = {
+  licenseKey: 1234,
+  applicationID: 9876
+};
+const init = {
+  session_replay: {
+    enabled: true,
+    sampleRate: 1,
+    errorSampleRate: 0
+  }
+};
+describe('Session Replay', () => {
+  beforeEach(async () => {
+    primeSessionAndReplay();
+  });
+  afterEach(async () => {
+    sr.abort();
+    jest.clearAllMocks();
+  });
+  describe('Session Replay Session Behavior', () => {
+    test('When Session Ends', async () => {
+      const xhrMockClass = () => ({
+        open: jest.fn(),
+        send: jest.fn(),
+        setRequestHeader: jest.fn(),
+        addEventListener: jest.fn()
+      });
+      global.XMLHttpRequest = jest.fn().mockImplementation(xhrMockClass);
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.initialized).toBeTruthy();
+      expect(sr.recording).toBeTruthy();
+      sr.ee.emit(_sessionEntity.SESSION_EVENTS.RESET);
+      expect(global.XMLHttpRequest).toHaveBeenCalled();
+      expect(sr.recording).toBeFalsy();
+      expect(sr.blocked).toBeTruthy();
+    });
+    test('When Session Is Paused/Resumed', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.initialized).toBeTruthy();
+      expect(sr.recording).toBeTruthy();
+      sr.ee.emit(_sessionEntity.SESSION_EVENTS.PAUSE);
+      expect(sr.recording).toBeFalsy();
+      sr.ee.emit(_sessionEntity.SESSION_EVENTS.RESUME);
+      expect(sr.recording).toBeTruthy();
+    });
+    test('Session SR mode matches SR mode -- FULL', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(session.state.sessionReplay).toEqual(sr.mode);
+    });
+    test('Session SR mode matches SR mode -- ERROR', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          sampleRate: 0,
+          errorSampleRate: 1
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(session.state.sessionReplay).toEqual(sr.mode);
+      return;
+    });
+    test('Session SR mode matches SR mode -- OFF', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          sampleRate: 0,
+          errorSampleRate: 0
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(session.state.sessionReplay).toEqual(sr.mode);
+      return;
+    });
+  });
+  describe('Session Replay Initialization Behavior', () => {
+    test('Waits for SR', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      // do not emit sr flag
+      await wait(1000);
+      expect(sr.initialized).toEqual(false);
+      expect(sr.recording).toEqual(false);
+
+      // emit a false flag
+      sr.ee.emit('rumresp-sr', [false]);
+      await wait(1);
+      expect(sr.initialized).toEqual(true);
+      expect(sr.recording).toEqual(false);
+      return;
+    });
+    test('Does not run if cookies_enabled is false', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init,
+        privacy: {
+          cookies_enabled: false
+        }
+      });
+      sr = new _.Aggregate(agentIdentifier, new _aggregator.Aggregator({}));
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.initialized).toEqual(false);
+      expect(sr.recording).toEqual(false);
+      return;
+    });
+    test('Does not run if session_trace is disabled', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init,
+        session_trace: {
+          enabled: false
+        }
+      });
+      sr = new _.Aggregate(agentIdentifier, new _aggregator.Aggregator({}));
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.initialized).toEqual(false);
+      expect(sr.recording).toEqual(false);
+      return;
+    });
+  });
+  describe('Session Replay Sample -> Mode Behaviors', () => {
+    test('New Session -- Full 1 Error 1 === FULL', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 1,
+          sampleRate: 1
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.FULL);
+      return;
+    });
+    test('New Session -- Full 1 Error 0 === FULL', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 0,
+          sampleRate: 1
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.FULL);
+      return;
+    });
+    test('New Session -- Full 0 Error 1 === ERROR', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 1,
+          sampleRate: 0
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.ERROR);
+      return;
+    });
+    test('New Session -- Full 0 Error 0 === OFF', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 0,
+          sampleRate: 0
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.OFF);
+      return;
+    });
+    test('Existing Session -- Should inherit mode from session entity and ignore samples', async () => {
+      const storage = new LocalMemory({
+        NRBA_SESSION: {
+          value: 'abcdefghijklmnop',
+          expiresAt: Date.now() + 10000,
+          inactiveAt: Date.now() + 10000,
+          updatedAt: Date.now(),
+          sessionReplay: _sessionEntity.MODE.FULL,
+          sessionTraceMode: _sessionEntity.MODE.FULL,
+          custom: {}
+        }
+      });
+      session = new _sessionEntity.SessionEntity({
+        agentIdentifier,
+        key: 'SESSION',
+        storage
+      });
+      expect(session.isNew).toBeFalsy();
+      primeSessionAndReplay(session);
+      // configure to get "error" sample ---> but should inherit FULL from session manager
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 1,
+          sampleRate: 0
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.FULL);
+      return;
+    });
+  });
+  describe('Session Replay Error Mode Behaviors', () => {
+    test('An error BEFORE rrweb import starts running in FULL from beginning', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 1,
+          sampleRate: 0
+        }
+      });
+      sr.ee.emit('errorAgg');
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.FULL);
+      expect(sr.scheduler.started).toEqual(true);
+      return;
+    });
+    test('An error AFTER rrweb import changes mode and starts harvester', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        session_replay: {
+          errorSampleRate: 1,
+          sampleRate: 0
+        }
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.ERROR);
+      expect(sr.scheduler.started).toEqual(false);
+      sr.ee.emit('errorAgg');
+      expect(sr.mode).toEqual(_sessionEntity.MODE.FULL);
+      expect(sr.scheduler.started).toEqual(true);
+      return;
+    });
+  });
+  describe('Session Replay Payload Validation', () => {
+    test('Payload', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      const harvestContents = sr.getHarvestContents();
+      // query attrs
+      expect(harvestContents.qs).toMatchObject({
+        protocol_version: '0',
+        content_encoding: 'gzip',
+        browser_monitoring_key: info.licenseKey
+      });
+      expect(harvestContents.body).toMatchObject({
+        type: 'SessionReplay',
+        appId: info.applicationID,
+        timestamp: expect.any(Number),
+        blob: expect.any(String),
+        attributes: {
+          session: session.state.value,
+          hasSnapshot: expect.any(Boolean),
+          hasError: expect.any(Boolean),
+          agentVersion: expect.any(String),
+          isFirstChunk: expect.any(Boolean),
+          'nr.rrweb.version': expect.any(String)
+        }
+      });
+      expect(JSON.parse(harvestContents.body.blob).length).toBeGreaterThan(0);
+    });
+  });
+  describe('Session Replay Harvest Behaviors', () => {
+    test('Compressed payload is provided to harvester', async () => {
+      const {
+        gunzipSync,
+        strFromU8
+      } = await Promise.resolve().then(() => _interopRequireWildcard(require('fflate')));
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      const [harvestContents] = sr.prepareHarvest();
+      expect(harvestContents.qs).toMatchObject({
+        protocol_version: '0',
+        content_encoding: 'gzip',
+        browser_monitoring_key: info.licenseKey
+      });
+      expect(harvestContents.body).toEqual(expect.any(Uint8Array));
+      expect(JSON.parse(strFromU8(gunzipSync(harvestContents.body)))).toMatchObject({
+        type: 'SessionReplay',
+        appId: info.applicationID,
+        timestamp: expect.any(Number),
+        blob: expect.any(String),
+        attributes: {
+          session: session.state.value,
+          hasSnapshot: expect.any(Boolean),
+          hasError: expect.any(Boolean),
+          agentVersion: expect.any(String),
+          isFirstChunk: expect.any(Boolean),
+          'nr.rrweb.version': expect.any(String)
+        }
+      });
+    });
+    test('Uncompressed payload is provided to harvester', async () => {
+      jest.doMock('fflate', () => ({
+        __esModule: true,
+        gzipSync: jest.fn().mockImplementation(() => {
+          throw new Error();
+        })
+      }));
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.shouldCompress = false;
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      const [harvestContents] = sr.prepareHarvest();
+      expect(harvestContents.qs).toMatchObject({
+        protocol_version: '0',
+        // content_encoding is omitted when the payload is not compressed
+        browser_monitoring_key: info.licenseKey
+      });
+      expect(harvestContents.qs.content_encoding).toBeUndefined();
+      expect(harvestContents.body).toMatchObject({
+        type: 'SessionReplay',
+        appId: info.applicationID,
+        timestamp: expect.any(Number),
+        blob: expect.any(String),
+        attributes: {
+          session: session.state.value,
+          hasSnapshot: expect.any(Boolean),
+          hasError: expect.any(Boolean),
+          agentVersion: expect.any(String),
+          isFirstChunk: expect.any(Boolean),
+          'nr.rrweb.version': expect.any(String)
+        }
+      });
+    });
+    test('Clears the event buffer when staged for harvesting', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.shouldCompress = false;
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      sr.prepareHarvest();
+      expect(sr.events.length).toEqual(0);
+    });
+    test('Harvests early if exceeds limit', async () => {
+      let after = 0;
+      const spy = jest.spyOn(sr.scheduler, 'runHarvest').mockImplementation(() => {
+        after = Date.now();
+      });
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.payloadBytesEstimation = _.IDEAL_PAYLOAD_SIZE / _.AVG_COMPRESSION;
+      const before = Date.now();
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(spy).toHaveBeenCalled();
+      expect(after - before).toBeLessThan(sr.harvestTimeSeconds * 1000);
+    });
+    test('Aborts if exceeds total limit', async () => {
+      const spy = jest.spyOn(sr.scheduler, 'runHarvest');
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.payloadBytesEstimation = (_.MAX_PAYLOAD_SIZE + 1) / _.AVG_COMPRESSION;
+      const before = Date.now();
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(spy).not.toHaveBeenCalled();
+      expect(sr.blocked).toEqual(true);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.OFF);
+    });
+    test('Aborts if 429 response', async () => {
+      (0, _config.setConfiguration)(agentIdentifier, {
+        ...init
+      });
+      sr.ee.emit('rumresp-sr', [true]);
+      await wait(1);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.FULL);
+      sr.onHarvestFinished({
+        status: 429
+      });
+      expect(sr.blocked).toEqual(true);
+      expect(sr.mode).toEqual(_sessionEntity.MODE.OFF);
+    });
+  });
+});
+function wait() {
+  let ms = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+function primeSessionAndReplay() {
+  let sess = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _sessionEntity.SessionEntity({
+    agentIdentifier,
+    key: 'SESSION',
+    storage: new LocalMemory()
+  });
+  session = sess;
+  (0, _configure.configure)(agentIdentifier, {
+    info,
+    runtime: {
+      session
+    }
+  }, 'test', true);
+  sr = new _.Aggregate(agentIdentifier, new _aggregator.Aggregator({}));
+}