@newrelic/browser-agent 1.234.0 → 1.236.0

package/dist/types/features/utils/instrument-base.d.ts

@@ -13,10 +13,19 @@ export class InstrumentBase extends FeatureBase {
      *     immediately. Primarily useful for fine-grained control in tests.
      */
     constructor(agentIdentifier: string, aggregator: Aggregator, featureName: string, auto?: boolean | undefined);
-    hasAggregator: boolean;
     auto: boolean;
     /** @type {Function | undefined} This should be set by any derived Instrument class if it has things to do when feature fails or is killed. */
     abortHandler: Function | undefined;
+    /**
+     * @type {Class} Holds the reference to the feature's aggregate module counterpart, if and after it has been initialized. This may not be assigned until after page loads!
+     * The only purpose of this for now is to expose it to the NREUM interface, as the feature's instrument instance is already exposed.
+    */
+    featAggregate: Class;
+    /**
+     * @type {Promise} Assigned immediately after @see importAggregator runs. Serves as a signal for when the inner async fn finishes execution. Useful for features to await
+     * one another if there are inter-features dependencies.
+    */
+    onAggregateImported: Promise<any>;
     /**
      * Lazy-load the latter part of the feature: its aggregator. This method is called by the first part of the feature
      * (the instrumentation) when instrumentation is complete.
@@ -24,6 +33,13 @@ export class InstrumentBase extends FeatureBase {
      * @returns void
      */
     importAggregator(argsObjFromInstrument?: Object | undefined): void;
+    /**
+   * Make a determination if an aggregate class should even be imported
+   * @param {string} featureName
+   * @param {SessionEntity} session
+   * @returns
+   */
+    shouldImportAgg(featureName: string, session: SessionEntity): boolean;
 }
 import { FeatureBase } from './feature-base';
 //# sourceMappingURL=instrument-base.d.ts.map

package/dist/types/features/utils/instrument-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6BAPW,MAAM,uCAEN,MAAM,8BAchB;IAPC,uBAA0B;IAC1B,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACd;IAKnB;;;;;OAKG;IACH,mEAyCC;CACF;4BAhF2B,gBAAgB"}
+{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6BAPW,MAAM,uCAEN,MAAM,8BAuBhB;IAhBC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACd;IACjB;;;MAGE;IACF,qBAAkB;IAClB;;;MAGE;IACF,kCAAwB;IAK1B;;;;;OAKG;IACH,mEA4CC;IAED;;;;;KAKC;IACD,6BAJS,MAAM,mCAed;CACF;4BA/G2B,gBAAgB"}

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 export { Agent } from "./loaders/agent";
 export { BrowserAgent } from "./loaders/browser-agent";
 export { WorkerAgent } from "./loaders/worker-agent";
+export { MicroAgent } from "./loaders/micro-agent";
 export { Ajax } from "./features/ajax";
 export { JSErrors } from "./features/jserrors";
 export { Metrics } from "./features/metrics";

package/dist/types/loaders/agent.d.ts

@@ -4,10 +4,10 @@
  */
 export class Agent {
     constructor(options: any, agentIdentifier?: string);
-    agentIdentifier: string;
-    sharedAggregator: Aggregator;
-    features: {};
-    desiredFeatures: Set<any>;
+    agentIdentifier: string | undefined;
+    sharedAggregator: Aggregator | undefined;
+    features: {} | undefined;
+    desiredFeatures: Set<any> | undefined;
     get config(): {
         info: any;
         init: any;

package/dist/types/loaders/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IACE,oDAeC;IAdC,wBAAsC;IACtC,6BAAiF;IACjF,aAAkB;IAElB,0BAAsD;IAYxD;;;;;MAOC;IAED,2BAgCC;CACF;2BAvE0B,gCAAgC"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE,oDAqBC;IAbC,oCAAsC;IACtC,yCAAiF;IACjF,yBAAkB;IAElB,sCAAsD;IAWxD;;;;;MAOC;IAED,2BAgCC;CACF;2BA9E0B,gCAAgC"}

package/dist/types/loaders/features/featureDependencies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"featureDependencies.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/featureDependencies.js"],"names":[],"mappings":"AAEA,kEAWC"}
+{"version":3,"file":"featureDependencies.d.ts","sourceRoot":"","sources":["../../../../src/loaders/features/featureDependencies.js"],"names":[],"mappings":"AAEA,kEAaC"}

package/dist/types/loaders/micro-agent.d.ts

@@ -1,8 +1,7 @@
 /**
- * A minimal agent class designed to be loaded multiple times on the same page, each instance narrowly scoped to the
- * concerns of a particular component, as with the micro-frontend architectural pattern. This class does not
- * automatically instrument. Instead, each MicroAgent instance may be configured to lazy-load specific
- * instrumentations at runtime, and to report desired data, events, and errors programatically.
+ * A minimal agent class designed to only respond to manual user input. As such, this class does not
+ * automatically instrument. Instead, each MicroAgent instance will lazy load the required features and can support loading multiple instances on one page.
+ * Out of the box, it can manually handle and report Page View, Page Action, and Error events.
  */
 export class MicroAgent {
     /**

package/dist/types/loaders/micro-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"micro-agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/micro-agent.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IACE;;;OAGG;IACH,qBAHW,MAAM,oBACN,MAAM,cAUhB;IAPC,wBAAsC;IACtC,6BAAiF;IACjF,aAAkB;IAOpB;;;;;MAOC;IAED,4BAgCC;CACF;2BA/E0B,gCAAgC"}
+{"version":3,"file":"micro-agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/micro-agent.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACE;;;OAGG;IACH,qBAHW,MAAM,oBACN,MAAM,cAUhB;IAPC,wBAAsC;IACtC,6BAAiF;IACjF,aAAkB;IAOpB;;;;;MAOC;IAED,4BA8BC;CACF;2BA1E0B,gCAAgC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.234.0",
+  "version": "1.236.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "Tests for the New Relic JavaScript agent",
@@ -37,6 +37,11 @@
       "require": "./dist/cjs/loaders/browser-agent.js",
       "default": "./dist/esm/loaders/browser-agent.js"
     },
+    "./loaders/micro-agent": {
+      "types": "./dist/types/loaders/micro-agent.d.ts",
+      "require": "./dist/cjs/loaders/micro-agent.js",
+      "default": "./dist/esm/loaders/micro-agent.js"
+    },
     "./loaders/worker-agent": {
       "types": "./dist/types/loaders/worker-agent.d.ts",
       "require": "./dist/cjs/loaders/worker-agent.js",
@@ -89,9 +94,8 @@
   "scripts": {
     "wdio": "node --max-old-space-size=8192 tools/wdio/bin/cli.js",
     "start": "npm-run-all --parallel cdn:watch test-server",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
+    "test:unit": "jest",
+    "test:component": "jest --config jest.component-config.js",
     "build:all": "npm run cdn:build:local && npm run build:npm && npm run tools:test-builds",
     "build:npm": "npm run npm:build:esm && npm run npm:build:cjs && npm run npm:build:types && npm run npm:pack",
     "build:browser-tests": "npm --prefix ./tools/test-builds/browser-tests run build",
@@ -196,10 +200,13 @@
     "gzip-size": "^7.0.0",
     "html-webpack-plugin": "^5.5.0",
     "husky": "^8.0.0",
-    "jest": "^28.1.1",
-    "jest-environment-jsdom": "28.1.1",
+    "istanbul-lib-coverage": "^3.2.0",
+    "istanbul-lib-instrument": "^5.2.1",
+    "istanbul-lib-report": "^3.0.0",
+    "istanbul-reports": "^3.1.5",
+    "jest": "^29.5.0",
+    "jest-environment-jsdom": "29.5.0",
     "jest-extended": "^3.2.4",
-    "jquery": "1.11.3",
     "jung": "^2.1.0",
     "just-debounce": "^1.0.0",
     "mime-types": "^2.1.11",

package/src/common/config/__mocks__/config.js

@@ -0,0 +1,11 @@
+export const isConfigured = jest.fn()
+export const getInfo = jest.fn()
+export const setInfo = jest.fn()
+export const getConfiguration = jest.fn()
+export const getConfigurationValue = jest.fn()
+export const setConfiguration = jest.fn()
+export const getLoaderConfig = jest.fn()
+export const setLoaderConfig = jest.fn()
+export const originals = {}
+export const getRuntime = jest.fn()
+export const setRuntime = jest.fn()

package/src/common/config/state/init.js

@@ -31,6 +31,7 @@ const model = () => {
     page_view_event: { enabled: true },
     page_view_timing: { enabled: true, harvestTimeSeconds: 30, long_task: false },
     session_trace: { enabled: true, harvestTimeSeconds: 10 },
+    harvest: { tooManyRequestsDelay: 60 },
     session_replay: {
       // feature settings
       enabled: false,

package/src/common/config/state/runtime.js

@@ -1,6 +1,6 @@
 import { getModeledObject } from './configurable'
 import { gosNREUMInitializedAgents } from '../../window/nreum'
-import { globalScope } from '../../util/global-scope'
+import { globalScope } from '../../constants/runtime'
 import { BUILD_ENV, DIST_METHOD, VERSION } from '../../constants/env'
 
 const model = {

package/src/common/constants/__mocks__/env.js

@@ -0,0 +1,3 @@
+export const VERSION = '0.0.0'
+export const BUILD_ENV = 'TEST'
+export const DIST_METHOD = 'TEST'

package/src/common/constants/__mocks__/runtime.js

@@ -0,0 +1,8 @@
+export const isBrowserScope = true
+export const isWorkerScope = false
+export const globalScope = window
+export const initialLocation = '' + globalScope?.location
+export const isiOS = false
+export const iOS_below16 = false
+export const ffVersion = 0
+export const supportsSendBeacon = true

package/src/common/constants/env.cdn.test.js

@@ -0,0 +1,7 @@
+import * as env from './env.cdn'
+
+test('should default environment variables to CDN values', async () => {
+  expect(env.VERSION).toMatch(/\d{1,3}\.\d{1,3}\.\d{1,3}/)
+  expect(env.BUILD_ENV).toEqual('CDN')
+  expect(env.DIST_METHOD).toEqual('CDN')
+})

package/src/common/constants/env.npm.test.js

@@ -0,0 +1,7 @@
+import * as env from './env.npm'
+
+test('should default environment variables to NPM values', () => {
+  expect(env.VERSION).toMatch(/\d{1,3}\.\d{1,3}\.\d{1,3}/)
+  expect(env.BUILD_ENV).toEqual('NPM')
+  expect(env.DIST_METHOD).toEqual('NPM')
+})

package/src/common/constants/env.test.js

@@ -0,0 +1,7 @@
+import * as env from './env'
+
+test('should default environment variables to NPM values', () => {
+  expect(env.VERSION).toMatch(/\d{1,3}\.\d{1,3}\.\d{1,3}/)
+  expect(env.BUILD_ENV).toEqual('NPM')
+  expect(env.DIST_METHOD).toEqual('NPM')
+})

package/src/common/constants/runtime.js

@@ -0,0 +1,71 @@
+/**
+ * @file Contains constants about the environment the agent is running
+ * within. These values are derived at the time the agent is first loaded.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+
+/**
+ * Indicates if the agent is running within a normal browser window context.
+ */
+export const isBrowserScope =
+  typeof window !== 'undefined' &&
+    !!window.document
+
+/**
+ * Indicates if the agent is running within a worker context.
+ */
+export const isWorkerScope =
+  typeof WorkerGlobalScope !== 'undefined' &&
+    (
+      (
+        typeof self !== 'undefined' &&
+        self instanceof WorkerGlobalScope &&
+        self.navigator instanceof WorkerNavigator
+      ) ||
+    (
+      (
+        typeof globalThis !== 'undefined' &&
+        globalThis instanceof WorkerGlobalScope &&
+        globalThis.navigator instanceof WorkerNavigator
+      )
+    )
+    )
+
+export const globalScope = isBrowserScope
+  ? window
+  : typeof WorkerGlobalScope !== 'undefined' && ((
+    typeof self !== 'undefined' &&
+      self instanceof WorkerGlobalScope &&
+      self
+  ) || (
+    typeof globalThis !== 'undefined' &&
+      globalThis instanceof WorkerGlobalScope &&
+      globalThis
+  ))
+
+export const initialLocation = '' + globalScope?.location
+
+export const isiOS = /iPad|iPhone|iPod/.test(navigator.userAgent)
+
+/**
+ * Shared Web Workers introduced in iOS 16.0+ and n/a in 15.6-
+ *
+ * It was discovered in Safari 14 (https://bugs.webkit.org/show_bug.cgi?id=225305) that the buffered flag in PerformanceObserver
+ * did not work. This affects our onFCP metric in particular since web-vitals uses that flag to retrieve paint timing entries.
+ * This was fixed in v16+.
+ */
+export const iOS_below16 = (isiOS && typeof SharedWorker === 'undefined')
+
+export const ffVersion = (() => {
+  const match = navigator.userAgent.match(/Firefox[/\s](\d+\.\d+)/)
+  if (Array.isArray(match) && match.length >= 2) {
+    return +match[1]
+  }
+
+  return 0
+})()
+
+export const isIE = Boolean(isBrowserScope && window.document.documentMode) // deprecated property that only works in IE
+
+export const supportsSendBeacon = !!navigator.sendBeacon

package/src/common/constants/runtime.test.js

@@ -0,0 +1,168 @@
+/**
+ * The runtime module exports variables whose values are set at the time of import and
+ * can depend on the environment the agent is running within. To make testing this module
+ * easier, use async import to import the module and only use the node jest environment so
+ * we can more easily define environment variables.
+ * @jest-environment node
+ */
+
+import { faker } from '@faker-js/faker'
+
+beforeEach(() => {
+  // We assume every runtime has a global navigator variable
+  global.navigator = {
+    userAgent: faker.lorem.sentence()
+  }
+})
+
+afterEach(() => {
+  delete global.navigator
+  jest.resetModules()
+})
+
+test('should indicate agent is running in a browser scope', async () => {
+  const mockedWindow = global.window = {
+    [faker.datatype.uuid()]: faker.lorem.sentence,
+    document: {
+      [faker.datatype.uuid()]: faker.lorem.sentence
+    }
+  }
+
+  const runtime = await import('./runtime')
+
+  delete global.window
+
+  expect(runtime.isBrowserScope).toEqual(true)
+  expect(runtime.isWorkerScope).toEqual(false)
+  expect(runtime.globalScope).toEqual(mockedWindow)
+})
+
+test('should indicate agent is running in a worker scope using global self variable', async () => {
+  global.WorkerGlobalScope = class WorkerGlobalScope {}
+  global.WorkerNavigator = class WorkerNavigator {}
+  const mockedGlobalSelf = global.self = new global.WorkerGlobalScope()
+  mockedGlobalSelf.navigator = new global.WorkerNavigator()
+
+  const runtime = await import('./runtime')
+
+  delete global.WorkerGlobalScope
+  delete global.WorkerNavigator
+  delete global.self
+
+  expect(runtime.isBrowserScope).toEqual(false)
+  expect(runtime.isWorkerScope).toEqual(true)
+  expect(runtime.globalScope).toEqual(mockedGlobalSelf)
+})
+
+test('should indicate agent is running in a worker scope using global self variable', async () => {
+  global.WorkerGlobalScope = class WorkerGlobalScope {}
+  global.WorkerNavigator = class WorkerNavigator {}
+  const cachedGlobalThis = global.globalThis
+  const mockedGlobalThis = global.globalThis = new WorkerGlobalScope()
+  Object.defineProperties(global.globalThis, Object.getOwnPropertyDescriptors(cachedGlobalThis))
+  global.globalThis.navigator = new WorkerNavigator()
+
+  const runtime = await import('./runtime')
+
+  delete global.WorkerGlobalScope
+  delete global.WorkerNavigator
+  global.globalThis = cachedGlobalThis
+
+  expect(runtime.isBrowserScope).toEqual(false)
+  expect(runtime.isWorkerScope).toEqual(true)
+  expect(runtime.globalScope).toEqual(mockedGlobalThis)
+})
+
+test('should store the initial page location', async () => {
+  const initialLocation = faker.internet.url()
+  const mockedWindow = global.window = {
+    [faker.datatype.uuid()]: faker.lorem.sentence,
+    document: {
+      [faker.datatype.uuid()]: faker.lorem.sentence
+    },
+    location: {
+      href: initialLocation,
+      toString () {
+        return this.href
+      }
+    }
+  }
+
+  const runtime = await import('./runtime')
+  mockedWindow.location.href = faker.internet.url()
+
+  delete global.window
+
+  expect(runtime.initialLocation).toEqual(initialLocation)
+  expect(runtime.initialLocation).not.toEqual(mockedWindow.location.href)
+})
+
+test.each([
+  { userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: true },
+  { userAgent: 'Mozilla/5.0 (iPad; CPU OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: true },
+  { userAgent: 'Mozilla/5.0 (iPod touch; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: true },
+  { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15', expected: false },
+  { userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0', expected: false },
+  { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13.4; rv:109.0) Gecko/20100101 Firefox/114.0', expected: false }
+])('should set isiOS to $expected for $userAgent', async ({ userAgent, expected }) => {
+  global.navigator.userAgent = userAgent
+
+  const runtime = await import('./runtime')
+
+  expect(runtime.isiOS).toEqual(expected)
+})
+
+test.each([
+  { userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: false },
+  { userAgent: 'Mozilla/5.0 (iPad; CPU OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: false },
+  { userAgent: 'Mozilla/5.0 (iPod touch; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: false },
+  { userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Mobile/15E148 Safari/604.1', expected: true },
+  { userAgent: 'Mozilla/5.0 (iPad; CPU OS 15_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Mobile/15E148 Safari/604.1', expected: true },
+  { userAgent: 'Mozilla/5.0 (iPod touch; CPU iPhone OS 15_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Mobile/15E148 Safari/604.1', expected: true },
+  { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15', expected: false },
+  { userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0', expected: false },
+  { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13.4; rv:109.0) Gecko/20100101 Firefox/114.0', expected: false }
+])('should set iOS_below16 to $expected for $userAgent', async ({ userAgent, expected }) => {
+  if (!expected) {
+    global.SharedWorker = class SharedWorker {}
+  }
+  global.navigator.userAgent = userAgent
+
+  const runtime = await import('./runtime')
+
+  delete global.SharedWorker
+
+  expect(runtime.iOS_below16).toEqual(expected)
+})
+
+test.each([
+  { userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: 0 },
+  { userAgent: 'Mozilla/5.0 (iPad; CPU OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: 0 },
+  { userAgent: 'Mozilla/5.0 (iPod touch; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1', expected: 0 },
+  { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15', expected: 0 },
+  { userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0', expected: 114 },
+  { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13.4; rv:109.0) Gecko/20100101 Firefox/114.0', expected: 114 }
+])('should set ffVersion to $expected for $userAgent', async ({ userAgent, expected }) => {
+  global.navigator.userAgent = userAgent
+
+  const runtime = await import('./runtime')
+
+  expect(runtime.ffVersion).toEqual(expected)
+})
+
+test('should set supportsSendBeacon to false', async () => {
+  // Ensure we don't have a sendBeacon function
+  delete global.navigator.sendBeacon
+
+  const runtime = await import('./runtime')
+
+  expect(runtime.supportsSendBeacon).toEqual(false)
+})
+
+test('should set supportsSendBeacon to true', async () => {
+  global.navigator.sendBeacon = jest.fn()
+
+  const runtime = await import('./runtime')
+
+  expect(runtime.supportsSendBeacon).toEqual(true)
+})

package/src/common/constants/shared-channel.js

@@ -0,0 +1,13 @@
+/**
+ * @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/src/common/context/__mocks__/shared-context.js

@@ -0,0 +1,8 @@
+export const SharedContext = jest.fn(function () {
+  this.sharedContext = {
+    agentIdentifier: 'abcd',
+    ee: {
+      on: jest.fn()
+    }
+  }
+})

package/src/common/event-listener/__mocks__/event-listener-opts.js

@@ -0,0 +1,7 @@
+export const eventListenerOpts = jest.fn((useCapture, abortSignal) => ({
+  capture: !!useCapture,
+  passive: true,
+  signal: abortSignal
+}))
+export const windowAddEventListener = jest.fn()
+export const documentAddEventListener = jest.fn()

package/src/common/event-listener/event-listener-opts.js

@@ -1,4 +1,4 @@
-import { globalScope } from '../util/global-scope'
+import { globalScope } from '../constants/runtime'
 
 /*
  * See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#safely_detecting_option_support

package/src/common/harvest/__mocks__/harvest.js

@@ -0,0 +1,13 @@
+export const Harvest = jest.fn(function () {
+  this.sharedContext = {
+    agentIdentifier: 'abcd'
+  }
+  this.sendX = jest.fn()
+  this.send = jest.fn()
+  this.obfuscateAndSend = jest.fn()
+  this._send = jest.fn()
+  this.baseQueryString = jest.fn()
+  this.createPayload = jest.fn()
+  this.cleanPayload = jest.fn()
+  this.on = jest.fn()
+})

package/src/common/harvest/harvest-scheduler.js

@@ -3,11 +3,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { submitData } from '../util/submit-data'
+import * as submitData from '../util/submit-data'
 import { SharedContext } from '../context/shared-context'
-import { Harvest, getSubmitMethod } from './harvest'
+import { Harvest } 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,10 +38,16 @@ 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.
@@ -64,30 +71,39 @@ export class HarvestScheduler extends SharedContext {
 
   scheduleHarvest (delay, opts) {
     if (this.timeoutHandle) return
-    var timer = this
 
     if (delay == null) {
       delay = this.interval
     }
     this.timeoutHandle = setTimeout(() => {
-      timer.timeoutHandle = null
-      timer.runHarvest(opts)
+      this.timeoutHandle = null
+      this.runHarvest(opts)
     }, delay * 1000)
   }
 
   runHarvest (opts) {
     if (this.aborted) return
-    var scheduler = this
+
+    /**
+     * 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
+     */
+    const cbRanAfterSend = (result) => {
+      if (opts?.forceNoRetry) result.retry = false // discard unsent data rather than re-queuing for next harvest attempt
+      this.onHarvestFinished(opts, result)
+    }
 
     let harvests = []
     let submitMethod
+    let payload
 
-    if (this.opts.getPayload) { // Ajax & PVT & SR
-      submitMethod = getSubmitMethod(this.endpoint, opts)
+    if (this.opts.getPayload) {
+      // Ajax & PVT & SR features provide a callback function to get data for harvesting
+      submitMethod = submitData.getSubmitMethod({ isFinalHarvest: opts?.unload })
       if (!submitMethod) return false
 
-      const retry = submitMethod.method === submitData.xhr
-      var payload = this.opts.getPayload({ retry: retry })
+      const retry = !opts?.unload && submitMethod === submitData.xhr
+      payload = this.opts.getPayload({ retry: retry })
 
       if (!payload) {
         if (this.started) {
@@ -118,7 +134,7 @@ export class HarvestScheduler extends SharedContext {
         payload,
         opts,
         submitMethod,
-        cbFinished: onHarvestFinished,
+        cbFinished: cbRanAfterSend,
         customUrl: this.opts.customUrl,
         raw: this.opts.raw
       })
@@ -127,12 +143,8 @@ export class HarvestScheduler extends SharedContext {
     if (this.started) {
       this.scheduleHarvest()
     }
-    return
 
-    function onHarvestFinished (result) {
-      if (result.blocked) scheduler.onHarvestBlocked(opts, result)
-      else scheduler.onHarvestFinished(opts, result)
-    }
+    return
   }
 
   onHarvestFinished (opts, result) {
@@ -141,7 +153,7 @@ export class HarvestScheduler extends SharedContext {
     }
 
     if (result.sent && result.retry) {
-      var delay = result.delay || this.opts.retryDelay
+      const delay = result.delay || this.opts.retryDelay
       // reschedule next harvest if should be delayed longer
       if (this.started && delay) {
         clearTimeout(this.timeoutHandle)