@newrelic/browser-agent 1.234.0 → 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/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.234.0";
+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.234.0";
+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/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) {