@newrelic/browser-agent 1.233.1 → 1.235.0

package/dist/cjs/features/utils/instrument-base.test.js

@@ -0,0 +1,179 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _instrumentBase = require("./instrument-base");
+var _featureBase = require("./feature-base");
+var _drain = require("../../common/drain/drain");
+var _load = require("../../common/window/load");
+var _lazyFeatureLoader = require("./lazy-feature-loader");
+var _config = require("../../common/config/config");
+var _agentSession = require("./agent-session");
+var _console = require("../../common/util/console");
+var globalScopeModule = _interopRequireWildcard(require("../../common/util/global-scope"));
+var _features = require("../../loaders/features/features");
+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; }
+jest.enableAutomock();
+jest.unmock('./instrument-base');
+jest.unmock('../../loaders/features/features');
+jest.mock('../../common/drain/drain', () => ({
+  __esModule: true,
+  drain: jest.fn(),
+  registerDrain: jest.fn()
+}));
+jest.mock('../../common/window/load', () => ({
+  __esModule: true,
+  onWindowLoad: jest.fn()
+}));
+jest.mock('../../common/util/global-scope', () => ({
+  __esModule: true,
+  isBrowserScope: undefined,
+  isWorkerScope: undefined
+}));
+jest.mock('../../common/config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn()
+}));
+jest.mock('./feature-base', () => ({
+  __esModule: true,
+  FeatureBase: jest.fn(function () {
+    this.agentIdentifier = arguments.length <= 0 ? undefined : arguments[0];
+    this.aggregator = arguments.length <= 1 ? undefined : arguments[1];
+    this.featureName = arguments.length <= 2 ? undefined : arguments[2];
+  })
+}));
+jest.mock('./agent-session', () => ({
+  __esModule: true,
+  setupAgentSession: jest.fn()
+}));
+let agentIdentifier;
+let aggregator;
+let featureName;
+let mockAggregate;
+beforeEach(() => {
+  jest.replaceProperty(globalScopeModule, 'isBrowserScope', true);
+  jest.replaceProperty(globalScopeModule, 'isWorkerScope', false);
+  agentIdentifier = _faker.faker.datatype.uuid();
+  aggregator = {};
+  featureName = _faker.faker.datatype.uuid();
+  mockAggregate = jest.fn(() => {/* noop */});
+  jest.mocked(_lazyFeatureLoader.lazyFeatureLoader).mockResolvedValue({
+    Aggregate: mockAggregate
+  });
+});
+test('should construct a new instrument', () => {
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, featureName);
+  expect(_featureBase.FeatureBase).toHaveBeenCalledWith(agentIdentifier, aggregator, featureName);
+  expect(instrument.featAggregate).toBeUndefined();
+  expect(instrument.auto).toEqual(true);
+  expect(instrument.abortHandler).toBeUndefined();
+  expect(_drain.registerDrain).toHaveBeenCalledWith(agentIdentifier, featureName);
+});
+test('should not immediately drain', () => {
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, featureName, false);
+  expect(_drain.registerDrain).not.toHaveBeenCalled();
+});
+test('should import aggregator on window load', async () => {
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, featureName);
+  const aggregateArgs = {
+    [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
+  };
+  instrument.importAggregator(aggregateArgs);
+  const windowLoadCallback = jest.mocked(_load.onWindowLoad).mock.calls[0][0];
+  await windowLoadCallback();
+  expect(_load.onWindowLoad).toHaveBeenCalledWith(expect.any(Function), true);
+  expect(_lazyFeatureLoader.lazyFeatureLoader).toHaveBeenCalledWith(featureName, 'aggregate');
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs);
+});
+test('should immediately import aggregator in worker scope', async () => {
+  jest.replaceProperty(globalScopeModule, 'isBrowserScope', false);
+  jest.replaceProperty(globalScopeModule, 'isWorkerScope', true);
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, featureName);
+  const aggregateArgs = {
+    [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
+  };
+  instrument.importAggregator(aggregateArgs);
+
+  // In worker scope, we cannot wait on importLater method
+  await new Promise(process.nextTick);
+  expect(_load.onWindowLoad).not.toHaveBeenCalled();
+  expect(_lazyFeatureLoader.lazyFeatureLoader).toHaveBeenCalledWith(featureName, 'aggregate');
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs);
+});
+test('should import the session manager and replay aggregate for new session', async () => {
+  jest.mocked(_config.getConfigurationValue).mockReturnValue(true);
+  jest.mocked(_agentSession.setupAgentSession).mockReturnValue({
+    isNew: true
+  });
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, _features.FEATURE_NAMES.sessionReplay);
+  const aggregateArgs = {
+    [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
+  };
+  instrument.importAggregator(aggregateArgs);
+  const windowLoadCallback = jest.mocked(_load.onWindowLoad).mock.calls[0][0];
+  await windowLoadCallback();
+  expect(_config.getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled');
+  expect(_agentSession.setupAgentSession).toHaveBeenCalledWith(agentIdentifier);
+  expect(_lazyFeatureLoader.lazyFeatureLoader).toHaveBeenCalledWith(_features.FEATURE_NAMES.sessionReplay, 'aggregate');
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs);
+});
+test('should import the session manager and replay aggregate when a recording is active', async () => {
+  jest.mocked(_config.getConfigurationValue).mockReturnValue(true);
+  jest.mocked(_agentSession.setupAgentSession).mockReturnValue({
+    isNew: false,
+    state: {
+      sessionReplay: 1
+    }
+  });
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, _features.FEATURE_NAMES.sessionReplay);
+  const aggregateArgs = {
+    [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
+  };
+  instrument.importAggregator(aggregateArgs);
+  const windowLoadCallback = jest.mocked(_load.onWindowLoad).mock.calls[0][0];
+  await windowLoadCallback();
+  expect(_config.getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled');
+  expect(_agentSession.setupAgentSession).toHaveBeenCalledWith(agentIdentifier);
+  expect(_lazyFeatureLoader.lazyFeatureLoader).toHaveBeenCalledWith(_features.FEATURE_NAMES.sessionReplay, 'aggregate');
+  expect(mockAggregate).toHaveBeenCalledWith(agentIdentifier, aggregator, aggregateArgs);
+});
+test('should not import session aggregate when session is not new and a recording is not active', async () => {
+  jest.mocked(_config.getConfigurationValue).mockReturnValue(true);
+  jest.mocked(_agentSession.setupAgentSession).mockReturnValue({
+    isNew: false,
+    state: {
+      sessionReplay: 0
+    }
+  });
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, _features.FEATURE_NAMES.sessionReplay);
+  const aggregateArgs = {
+    [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
+  };
+  instrument.importAggregator(aggregateArgs);
+  const windowLoadCallback = jest.mocked(_load.onWindowLoad).mock.calls[0][0];
+  await windowLoadCallback();
+  expect(_config.getConfigurationValue).toHaveBeenCalledWith(agentIdentifier, 'privacy.cookies_enabled');
+  expect(_agentSession.setupAgentSession).toHaveBeenCalledWith(agentIdentifier);
+  expect(_drain.drain).toHaveBeenCalledWith(agentIdentifier, _features.FEATURE_NAMES.sessionReplay);
+  expect(_lazyFeatureLoader.lazyFeatureLoader).not.toHaveBeenCalled();
+  expect(mockAggregate).not.toHaveBeenCalled();
+});
+test('feature still imports by default even when setupAgentSession throws an error', async () => {
+  jest.mocked(_config.getConfigurationValue).mockReturnValue(true);
+  jest.mocked(_agentSession.setupAgentSession).mockImplementation(() => {
+    throw new Error(_faker.faker.lorem.sentence());
+  });
+  const instrument = new _instrumentBase.InstrumentBase(agentIdentifier, aggregator, featureName);
+  const aggregateArgs = {
+    [_faker.faker.datatype.uuid()]: _faker.faker.lorem.sentence()
+  };
+  instrument.abortHandler = jest.fn();
+  instrument.importAggregator(aggregateArgs);
+  const windowLoadCallback = jest.mocked(_load.onWindowLoad).mock.calls[0][0];
+  await windowLoadCallback();
+  expect(_load.onWindowLoad).toHaveBeenCalledWith(expect.any(Function), true);
+  expect(instrument.abortHandler).not.toHaveBeenCalled();
+  expect(_console.warn).toHaveBeenCalledWith(expect.stringContaining('A problem occurred when starting up session manager'), expect.any(Error));
+  expect(_lazyFeatureLoader.lazyFeatureLoader).toHaveBeenCalled();
+  expect(mockAggregate).toHaveBeenCalled();
+});

package/dist/cjs/features/utils/lazy-feature-loader.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _features = require("../../loaders/features/features");
+var _lazyFeatureLoader = require("./lazy-feature-loader");
+// Use enableAutomock to make it easier to mock all the things that get imported by the aggregators
+jest.enableAutomock();
+// Unmock the file under test and the constants file
+jest.unmock('../../loaders/features/features');
+jest.unmock('./lazy-feature-loader');
+test.each(Object.keys(_features.FEATURE_NAMES))('should import the aggregate for feature %s', async key => {
+  const featureName = _features.FEATURE_NAMES[key];
+  const randomId = _faker.faker.datatype.uuid();
+  jest.setMock("../".concat(featureName, "/aggregate"), {
+    id: randomId,
+    featureName
+  });
+  const result = await (0, _lazyFeatureLoader.lazyFeatureLoader)(featureName, 'aggregate');
+  expect(result.id).toEqual(randomId);
+  expect(result.featureName).toEqual(featureName);
+});
+test('should throw an error when the featureName is not supported', async () => {
+  const featureName = _faker.faker.datatype.uuid();
+  expect(() => (0, _lazyFeatureLoader.lazyFeatureLoader)(featureName, 'aggregate')).toThrow();
+});
+test('should return undefined when the featurePart is not supported', async () => {
+  const featureName = _faker.faker.datatype.uuid();
+  const featurePart = _faker.faker.datatype.uuid();
+  expect((0, _lazyFeatureLoader.lazyFeatureLoader)(featureName, featurePart)).toBeUndefined();
+});

package/dist/cjs/loaders/agent.js

@@ -34,7 +34,6 @@ class Agent {
     });
     this.features = {};
     this.desiredFeatures = new Set(options.features || []); // expected to be a list of static Instrument/InstrumentBase classes, see "spa.js" for example
-
     // For Now... ALL agents must make the rum call whether the page_view_event feature was enabled or not.
     // NR1 creates an index on the rum call, and if not seen for a few days, will remove the browser app!
     // Future work is being planned to evaluate removing this behavior from the backend, but for now we must ensure this call is made

package/dist/cjs/loaders/api/api.js

@@ -158,7 +158,7 @@ function setAPI(agentIdentifier, forceDrain) {
   };
 
   // theres no window.load event on non-browser scopes, lazy load immediately
-  if (_globalScope.isWorkerScope) lazyLoad();
+  if (!_globalScope.isBrowserScope) lazyLoad();
   // try to stay out of the way of the window.load event, lazy load once that has finished.
   else (0, _load.onWindowLoad)(() => lazyLoad(), true);
   function lazyLoad() {

package/dist/cjs/loaders/configure/configure.js

@@ -42,6 +42,5 @@ function configure(agentIdentifier) {
   (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, api, 'api');
   (0, _nreum.gosNREUMInitializedAgents)(agentIdentifier, exposed, 'exposed');
   (0, _nreum.addToNREUM)('activatedFeatures', _featureFlags.activatedFeatures);
-  (0, _nreum.addToNREUM)('setToken', flags => (0, _featureFlags.activateFeatures)(flags, agentIdentifier));
   return api;
 }

package/dist/cjs/loaders/features/featureDependencies.js

@@ -11,6 +11,8 @@ function getFeatureDependencyNames(feature) {
       return [_features.FEATURE_NAMES.jserrors];
     case _features.FEATURE_NAMES.sessionTrace:
       return [_features.FEATURE_NAMES.ajax, _features.FEATURE_NAMES.pageViewEvent];
+    case _features.FEATURE_NAMES.sessionReplay:
+      return [_features.FEATURE_NAMES.sessionTrace];
     case _features.FEATURE_NAMES.pageViewTiming:
       return [_features.FEATURE_NAMES.pageViewEvent];
     // this could change if we disconnect window load timings

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.233.1";
+export const VERSION = "1.235.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.233.1";
+export const VERSION = "1.235.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/shared-channel.js

@@ -0,0 +1,12 @@
+/**
+ * @file Keeps an object alive that is passed to all feature aggregate modules.
+ * The purpose is to have a way for communication and signals to relay across features at runtime.
+ * This object can hold any arbitrary values and should be treated as on-the-fly dynamic.
+ */
+
+let onReplayReady;
+const sessionReplayInitialized = new Promise(resolve => onReplayReady = resolve);
+export const sharedChannel = Object.freeze({
+  onReplayReady,
+  sessionReplayInitialized
+});

package/dist/esm/common/event-emitter/contextual-ee.test.js

@@ -89,7 +89,7 @@ describe('event-emitter context', () => {
   });
 });
 describe('event-emitter buffer', () => {
-  it('it should create a new buffer for the given group', async () => {
+  test('it should create a new buffer for the given group', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -101,7 +101,7 @@ describe('event-emitter buffer', () => {
     }));
     expect(ee.isBuffering(eventType)).toEqual(true);
   });
-  it('it should default group to "feature"', async () => {
+  test('it should default group to "feature"', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -112,7 +112,7 @@ describe('event-emitter buffer', () => {
     }));
     expect(ee.isBuffering(eventType)).toEqual(true);
   });
-  it('it should not create buffer if event-emitter is aborted', async () => {
+  test('it should not create buffer if event-emitter is aborted', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -152,7 +152,7 @@ describe('event-emitter abort', () => {
   });
 });
 describe('event-emitter emit', () => {
-  it('should execute the listener', async () => {
+  test('should execute the listener', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -163,7 +163,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledWith(eventArgs[0], eventArgs[1], eventArgs[2]);
   });
-  it('should not execute the listener after removal', async () => {
+  test('should not execute the listener after removal', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -176,7 +176,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledTimes(1);
   });
-  it('should return early if global event-emitter is aborted', async () => {
+  test('should return early if global event-emitter is aborted', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -191,7 +191,7 @@ describe('event-emitter emit', () => {
     ee.emit(eventType, eventArgs);
     expect(mockListener).toHaveBeenCalledTimes(0);
   });
-  it('should still emit if global event-emitter is aborted but force flag is true', async () => {
+  test('should still emit if global event-emitter is aborted but force flag is true', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -207,7 +207,7 @@ describe('event-emitter emit', () => {
     scopeEE.emit(eventType, eventArgs, {}, true);
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
   });
-  it('should bubble the event if bubble flag is true', async () => {
+  test('should bubble the event if bubble flag is true', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -222,7 +222,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
     expect(mockListener).toHaveBeenCalledTimes(1);
   });
-  it('should not bubble the event if bubble flag is false', async () => {
+  test('should not bubble the event if bubble flag is false', async () => {
     const {
       ee
     } = await import('./contextual-ee');
@@ -237,7 +237,7 @@ describe('event-emitter emit', () => {
     expect(mockScopeListener).toHaveBeenCalledTimes(1);
     expect(mockListener).not.toHaveBeenCalled();
   });
-  it('should buffer the event on the scoped event-emitter', async () => {
+  test('should buffer the event on the scoped event-emitter', async () => {
     const {
       ee
     } = await import('./contextual-ee');

package/dist/esm/common/harvest/{harvest-scheduler.test.js → harvest-scheduler.component-test.js}

@@ -1,7 +1,7 @@
 import { setConfiguration } from '../config/state/init';
 import { HarvestScheduler } from './harvest-scheduler';
 describe('runHarvest', () => {
-  it('should re-schedule harvest even if there is no accumulated data', () => {
+  test('should re-schedule harvest even if there is no accumulated data', () => {
     setConfiguration('asdf', {});
     const scheduler = new HarvestScheduler('events', {
       getPayload: jest.fn()
@@ -17,7 +17,7 @@ describe('runHarvest', () => {
     expect(scheduler.opts.getPayload()).toBeFalsy();
     expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
   });
-  it('should also re-schedule harvest if there is accumulated data', () => {
+  test('should also re-schedule harvest if there is accumulated data', () => {
     setConfiguration('asdf', {});
     const scheduler = new HarvestScheduler('events', {
       getPayload: jest.fn().mockImplementation(() => 'payload')

package/dist/esm/common/harvest/harvest-scheduler.js

@@ -8,6 +8,7 @@ import { SharedContext } from '../context/shared-context';
 import { Harvest, getSubmitMethod } from './harvest';
 import { subscribeToEOL } from '../unload/eol';
 import { getConfigurationValue } from '../config/config';
+import { SESSION_EVENTS } from '../session/session-entity';
 
 /**
  * Periodically invokes harvest calls and handles retries
@@ -37,9 +38,18 @@ export class HarvestScheduler extends SharedContext {
     // unload if EOL mechanism fires
     subscribeToEOL(this.unload.bind(this), getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
 
-    // unload if session resets
-    this.sharedContext?.ee.on('session-reset', this.unload.bind(this));
+    /* Flush all buffered data if session resets and give up retries. This should be synchronous to ensure that the correct `session` value is sent.
+      Since session-reset generates a new session ID and the ID is grabbed at send-time, any delays or retries would cause the payload to be sent under
+      the wrong session ID. */
+    this.sharedContext?.ee.on(SESSION_EVENTS.RESET, () => this.runHarvest({
+      forceNoRetry: true
+    }));
   }
+
+  /**
+   * This function is only meant for the last outgoing harvest cycle of a page. It trickles down to using sendBeacon, which should not be used
+   * to send payloads while the page is still active, due to limitations on how much data can be buffered in the API at any one time.
+   */
   unload() {
     if (this.aborted) return;
     // If opts.onUnload is defined, these are special actions to execute before attempting to send the final payload.
@@ -111,7 +121,7 @@ export class HarvestScheduler extends SharedContext {
         payload,
         opts,
         submitMethod,
-        cbFinished: onHarvestFinished,
+        cbFinished: cbRanAfterSend,
         customUrl: this.opts.customUrl,
         raw: this.opts.raw
       });
@@ -120,8 +130,14 @@ export class HarvestScheduler extends SharedContext {
       this.scheduleHarvest();
     }
     return;
-    function onHarvestFinished(result) {
-      if (result.blocked) scheduler.onHarvestBlocked(opts, result);else scheduler.onHarvestFinished(opts, result);
+
+    /**
+     * This is executed immediately after harvest sends the data via XHR, or if there's nothing to send. Note that this excludes on unloading / sendBeacon.
+     * @param {Object} result
+     */
+    function cbRanAfterSend(result) {
+      if (opts?.forceNoRetry) result.retry = false; // discard unsent data rather than re-queuing for next harvest attempt
+      scheduler.onHarvestFinished(opts, result);
     }
   }
   onHarvestFinished(opts, result) {

package/dist/esm/common/harvest/harvest.component-test.js

@@ -0,0 +1,222 @@
+import { submitData } from '../util/submit-data';
+import { Harvest } from './harvest';
+jest.mock('../context/shared-context', () => ({
+  __esModule: true,
+  SharedContext: function () {
+    this.sharedContext = {
+      agentIdentifier: 'abcd'
+    };
+  }
+}));
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn(),
+  getInfo: jest.fn().mockReturnValue({
+    errorBeacon: 'example.com',
+    licenseKey: 'abcd'
+  }),
+  getRuntime: jest.fn().mockReturnValue({
+    bytesSent: {},
+    queryBytesSent: {}
+  })
+}));
+jest.mock('../util/submit-data', () => ({
+  __esModule: true,
+  submitData: {
+    xhr: jest.fn(() => ({
+      addEventListener: jest.fn()
+    })),
+    beacon: jest.fn(),
+    img: jest.fn()
+  }
+}));
+describe('sendX', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
+    const sendCallback = jest.fn();
+    const harvester = new Harvest();
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: sendCallback
+    });
+    expect(sendCallback).toHaveBeenCalledWith({
+      sent: false
+    });
+    expect(submitData.xhr).not.toHaveBeenCalled();
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new Harvest();
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      opts: {
+        sendEmptyBody: true
+      },
+      cbFinished: jest.fn()
+    });
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/jserrors/1/abcd?'),
+      body: undefined
+    }));
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
+    const harvester = new Harvest();
+    harvester.on('jserrors', () => ({
+      body: {
+        bar: 'foo',
+        empty: emptyValue
+      },
+      qs: {
+        foo: 'bar',
+        empty: emptyValue
+      }
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: jest.fn()
+    });
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({
+        bar: 'foo'
+      })
+    }));
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }));
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
+    const harvester = new Harvest();
+    harvester.on('jserrors', () => ({
+      body: {
+        bar: 'foo',
+        nonString: nonStringValue
+      },
+      qs: {
+        foo: 'bar',
+        nonString: nonStringValue
+      }
+    }));
+    harvester.sendX({
+      endpoint: 'jserrors',
+      cbFinished: jest.fn()
+    });
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
+      body: JSON.stringify({
+        bar: 'foo',
+        nonString: nonStringValue
+      })
+    }));
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+});
+describe('send', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', sendEmptyBody => {
+    const sendCallback = jest.fn();
+    const harvester = new Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {},
+        body: {}
+      },
+      opts: {
+        sendEmptyBody
+      },
+      cbFinished: sendCallback
+    });
+    expect(sendCallback).toHaveBeenCalledWith({
+      sent: false
+    });
+    expect(submitData.xhr).not.toHaveBeenCalled();
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {},
+        body: {}
+      },
+      opts: {
+        sendEmptyBody: true
+      }
+    });
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/1/abcd?'),
+      body: undefined
+    }));
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', emptyValue => {
+    const harvester = new Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {
+          foo: 'bar',
+          empty: emptyValue
+        },
+        body: {
+          bar: 'foo',
+          empty: emptyValue
+        }
+      }
+    });
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({
+        bar: 'foo'
+      })
+    }));
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }));
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', nonStringValue => {
+    const harvester = new Harvest();
+    harvester.send({
+      endpoint: 'rum',
+      payload: {
+        qs: {
+          foo: 'bar',
+          nonString: nonStringValue
+        },
+        body: {
+          bar: 'foo',
+          nonString: nonStringValue
+        }
+      }
+    });
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining("&nonString=".concat(nonStringValue)),
+      body: JSON.stringify({
+        bar: 'foo',
+        nonString: nonStringValue
+      })
+    }));
+    expect(submitData.img).not.toHaveBeenCalled();
+    expect(submitData.beacon).not.toHaveBeenCalled();
+  });
+});