@newrelic/browser-agent 1.276.0 → 1.278.0

package/src/features/spa/aggregate/index.js

@@ -10,11 +10,10 @@ import { navTimingValues as navTiming } from '../../../common/timing/nav-timing'
 import { generateUuid } from '../../../common/ids/unique-id'
 import { Interaction } from './interaction'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { Serializer } from './serializer'
 import { ee } from '../../../common/event-emitter/contextual-ee'
 import * as CONSTANTS from '../constants'
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint'
 import { firstPaint } from '../../../common/vitals/first-paint'
@@ -46,14 +45,12 @@ export class Aggregate extends AggregateBase {
       pageLoaded: false,
       childTime: 0,
       depth: 0,
-      harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
       // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
       disableSpaFix: (agentRef.init.feature_flags || []).indexOf('disable-spa-fix') > -1
     }
     this.spaSerializerClass = new Serializer(this)
 
     const classThis = this
-    let scheduler
 
     const baseEE = ee.get(agentRef.agentIdentifier) // <-- parent baseEE
     const mutationEE = baseEE.get('mutation')
@@ -98,13 +95,10 @@ export class Aggregate extends AggregateBase {
     //  | click ending:                   |   65  |    50    |        |           |           |
     // click fn-end                       |   70  |    0     |    0   |     70    |     20    |
 
+    let harvester
     this.waitForFlags((['spa'])).then(([spaFlag]) => {
       if (spaFlag) {
-        scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: (result) => this.postHarvestCleanup(result.sent && result.retry),
-          getPayload: (options) => this.makeHarvestPayload(options.retry),
-          retryDelay: state.harvestTimeSeconds
-        }, this)
+        harvester = agentRef.runtime.harvester // since this is after RUM call, PVE would've initialized harvester by now
         this.drain()
       } else {
         this.blocked = true
@@ -725,8 +719,11 @@ export class Aggregate extends AggregateBase {
       else smCategory = 'Custom'
       handle(SUPPORTABILITY_METRIC_CHANNEL, [`Spa/Interaction/${smCategory}/Duration/Ms`, Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, FEATURE_NAMES.metrics, baseEE)
 
-      scheduler?.scheduleHarvest(0)
-      if (!scheduler) warn(19)
+      if (!harvester) {
+        warn(19)
+        return
+      }
+      harvester.triggerHarvestFor(classThis)
     }
   }
 

package/src/features/utils/aggregate-base.js

@@ -5,19 +5,34 @@ import { gosCDN } from '../../common/window/nreum'
 import { drain } from '../../common/drain/drain'
 import { activatedFeatures } from '../../common/util/feature-flags'
 import { Obfuscator } from '../../common/util/obfuscate'
-import { EventBuffer } from './event-buffer'
 import { FEATURE_NAMES } from '../../loaders/features/features'
+import { EventStoreManager } from './event-store-manager'
+import { Harvester } from '../../common/harvest/harvester'
 
 export class AggregateBase extends FeatureBase {
   constructor (agentRef, featureName) {
     super(agentRef.agentIdentifier, featureName)
     this.agentRef = agentRef
-    // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
-    if ([FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics].includes(this.featureName)) this.events = agentRef.sharedAggregator
-    // PVE has no need for eventBuffer, and SessionTrace has its own storage mechanism.
-    else if (![FEATURE_NAMES.pageViewEvent, FEATURE_NAMES.sessionTrace].includes(this.featureName)) this.events = new EventBuffer()
     this.checkConfiguration(agentRef)
-    this.obfuscator = agentRef.runtime.obfuscator
+    this.doOnceForAllAggregate(agentRef)
+
+    // This switch needs to be after doOnceForAllAggregate which may new sharedAggregator and reset mainAppKey.
+    switch (this.featureName) {
+      // PVE has no need for eventBuffer, and SessionTrace + Replay have their own storage mechanisms.
+      case FEATURE_NAMES.pageViewEvent:
+      case FEATURE_NAMES.sessionTrace:
+      case FEATURE_NAMES.sessionReplay:
+        break
+      // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
+      case FEATURE_NAMES.jserrors:
+      case FEATURE_NAMES.metrics:
+        this.events = agentRef.sharedAggregator
+        break
+      default:
+        this.events = new EventStoreManager(agentRef.mainAppKey, 1)
+        break
+    }
+    this.harvestOpts = {} // features aggregate classes can define custom opts for when their harvest is called
   }
 
   /**
@@ -56,34 +71,40 @@ export class AggregateBase extends FeatureBase {
   /**
    * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
    * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic
-   * @returns final payload, or undefined if there are no pending events
+   * @param {object|undefined} target - the target app passed onto the event store manager to determine which app's data to return; if none provided, all apps data will be returned
+   * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
    */
-  makeHarvestPayload (shouldRetryOnFail = false, opts = {}) {
-    if (this.events.isEmpty(opts)) return
+  makeHarvestPayload (shouldRetryOnFail = false, target) {
+    if (this.events.isEmpty(this.harvestOpts, target)) return
     // Other conditions and things to do when preparing harvest that is required.
     if (this.preHarvestChecks && !this.preHarvestChecks()) return
 
-    if (shouldRetryOnFail) this.events.save(opts)
-    const returnedData = this.events.get(opts)
-    // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
-    const body = this.serializer ? this.serializer(returnedData) : returnedData
-    this.events.clear(opts)
+    if (shouldRetryOnFail) this.events.save(this.harvestOpts, target)
+    const returnedDataArr = this.events.get(this.harvestOpts, target)
+    if (!returnedDataArr.length) throw new Error('Unexpected problem encountered. There should be at least one app for harvest!')
+    this.events.clear(this.harvestOpts, target)
 
-    const payload = {
-      body
-    }
-    // Constructs the payload `qs` for relevant features on harvest.
-    if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(returnedData)
-    return payload
+    return returnedDataArr.map(({ targetApp, data }) => {
+      // A serializer or formatter assists in creating the payload `body` from stored events on harvest when defined by derived feature class.
+      const body = this.serializer ? this.serializer(data) : data
+      const payload = {
+        body
+      }
+      // Constructs the payload `qs` for relevant features on harvest.
+      if (this.queryStringsBuilder) payload.qs = this.queryStringsBuilder(data)
+
+      return { targetApp, payload }
+    })
   }
 
   /**
    * Cleanup task after a harvest.
-   * @param {Boolean} harvestFailed - harvester flag to restore events in main buffer for retry later if request failed
+   * @param {object} result - the cbResult object from the harvester's send method
    */
-  postHarvestCleanup (harvestFailed = false, opts = {}) {
-    if (harvestFailed) this.events.reloadSave(opts)
-    this.events.clearSave(opts)
+  postHarvestCleanup (result = {}) {
+    const harvestFailed = result.sent && result.retry
+    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp)
+    this.events.clearSave(this.harvestOpts, result.targetApp)
   }
 
   /**
@@ -112,9 +133,20 @@ export class AggregateBase extends FeatureBase {
         runtime: existingAgent.runtime
       })
     }
+  }
 
-    if (!existingAgent.runtime.obfuscator) {
-      existingAgent.runtime.obfuscator = new Obfuscator(this.agentIdentifier)
-    }
+  /**
+   * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
+   * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
+   */
+  doOnceForAllAggregate (agentRef) {
+    if (!agentRef.runtime.obfuscator) agentRef.runtime.obfuscator = new Obfuscator(this.agentIdentifier)
+    this.obfuscator = agentRef.runtime.obfuscator
+
+    if (!agentRef.mainAppKey) agentRef.mainAppKey = { licenseKey: agentRef.info.licenseKey, appId: agentRef.info.applicationID }
+    // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
+    if (!agentRef.sharedAggregator) agentRef.sharedAggregator = new EventStoreManager(agentRef.mainAppKey, 2)
+
+    if (!agentRef.runtime.harvester) agentRef.runtime.harvester = new Harvester(agentRef)
   }
 }

package/src/features/utils/event-buffer.js

@@ -53,7 +53,6 @@ export class EventBuffer {
 
   /**
    * Backup the buffered data and clear the main buffer
-   * @returns {Array} the events being backed up
    */
   save () {
     this.#bufferBackup = this.#buffer

package/src/features/utils/event-store-manager.js

@@ -0,0 +1,101 @@
+import { EventAggregator } from '../../common/aggregate/event-aggregator'
+import { EventBuffer } from './event-buffer'
+
+/**
+ * This layer allows multiple browser entity apps, or "target", to each have their own segregated storage instance.
+ * The purpose is so the harvester can send data to different apps within the same agent. Each feature should have a manager if it needs this capability.
+ */
+export class EventStoreManager {
+  /**
+   * @param {object} defaultTarget - should contain licenseKey and appId of the main app from NREUM.info at startup
+   * @param {1|2} storageChoice - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
+   */
+  constructor (defaultTarget, storageChoice) {
+    this.mainApp = defaultTarget
+    this.StorageClass = storageChoice === 1 ? EventBuffer : EventAggregator
+    this.appStorageMap = new Map()
+    this.appStorageMap.set(defaultTarget, new this.StorageClass())
+  }
+
+  // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
+
+  /**
+   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+   * @param {object} target - specific app's storage to check; if not provided, this method takes into account all apps recorded by this manager
+   * @returns {boolean} True if the target's storage is empty, or target does not exist in map (defaults to all storages)
+   */
+  isEmpty (optsIfPresent, target) {
+    if (target) {
+      if (!this.appStorageMap.has(target)) return true
+      else return this.appStorageMap.get(target).isEmpty(optsIfPresent)
+    }
+    for (const eventStore of this.appStorageMap.values()) {
+      if (!eventStore.isEmpty(optsIfPresent)) return false
+    }
+    return true
+  }
+
+  /**
+   * @param {string} event - the event element to store
+   * @param {object} target - the app to store event under; if not provided, this method adds to the main app from NREUM.info
+   * @returns {boolean} True if the event was successfully added
+   */
+  add (event, target) {
+    if (target && !this.appStorageMap.has(target)) this.appStorageMap.set(target, new this.StorageClass())
+    return this.appStorageMap.get(target || this.mainApp).add(event)
+  }
+
+  /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
+  addMetric (type, name, params, value) {
+    return this.appStorageMap.get(this.mainApp).addMetric(type, name, params, value)
+  }
+
+  /**
+   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+   * @param {object} target - specific app to fetch; if not provided, this method fetches from all apps
+   * @returns {Array} Objects of `data` labeled with their respective `target` app to be sent to
+   */
+  get (optsIfPresent, target) {
+    if (target) return [{ targetApp: target, data: this.appStorageMap.get(target)?.get(optsIfPresent) }]
+    const allPayloads = []
+    this.appStorageMap.forEach((eventStore, recordedTarget) => {
+      allPayloads.push({ targetApp: recordedTarget, data: eventStore.get(optsIfPresent) })
+    })
+    return allPayloads
+  }
+
+  byteSize (target) {
+    return this.appStorageMap.get(target || this.mainApp).byteSize()
+  }
+
+  wouldExceedMaxSize (incomingSize, target) {
+    return this.appStorageMap.get(target || this.mainApp).wouldExceedMaxSize(incomingSize)
+  }
+
+  save (optsIfPresent, target) {
+    if (target) return this.appStorageMap.get(target)?.save(optsIfPresent)
+    this.appStorageMap.forEach((eventStore) => eventStore.save(optsIfPresent))
+  }
+
+  clear (optsIfPresent, target) {
+    if (target) return this.appStorageMap.get(target)?.clear(optsIfPresent)
+    this.appStorageMap.forEach((eventStore) => eventStore.clear(optsIfPresent))
+  }
+
+  // Unlike the methods above, the following will have a target as they are called by AggregateBase.postHarvestCleanup callback on harvest finish after getting & sending the data.
+  reloadSave (optsIfPresent, target) {
+    if (!target) { // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
+      this.appStorageMap.forEach((eventStore) => eventStore.reloadSave(optsIfPresent))
+      return
+    }
+    return this.appStorageMap.get(target)?.reloadSave(optsIfPresent)
+  }
+
+  clearSave (optsIfPresent, target) {
+    if (!target) { // -- remove this block once the old harvest.js & harvest-schedule.js are deleted!
+      this.appStorageMap.forEach((eventStore) => eventStore.clearSave(optsIfPresent))
+      return
+    }
+    return this.appStorageMap.get(target)?.clearSave(optsIfPresent)
+  }
+}

package/src/features/utils/instrument-base.js

@@ -43,7 +43,6 @@ export class InstrumentBase extends FeatureBase {
     /**
      * @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.
-     * TODO: This is only used for the SPA feature component tests and should be refactored out.
     */
     this.onAggregateImported = undefined
 
@@ -95,13 +94,6 @@ export class InstrumentBase extends FeatureBase {
        * it's only responsible for aborting its one specific feature, rather than all.
        */
       try {
-        // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
-        if (!agentRef.sharedAggregator) {
-          agentRef.sharedAggregator = import(/* webpackChunkName: "shared-aggregator" */ '../../common/aggregate/event-aggregator')
-          const { EventAggregator } = await agentRef.sharedAggregator
-          agentRef.sharedAggregator = new EventAggregator()
-        } else await agentRef.sharedAggregator // if another feature is already importing the aggregator, wait for it to finish
-
         if (!this.#shouldImportAgg(this.featureName, session)) {
           drain(this.agentIdentifier, this.featureName)
           loadedSuccessfully(false) // aggregate module isn't loaded at all
@@ -110,6 +102,8 @@ export class InstrumentBase extends FeatureBase {
         const { lazyFeatureLoader } = await import(/* webpackChunkName: "lazy-feature-loader" */ './lazy-feature-loader')
         const { Aggregate } = await lazyFeatureLoader(this.featureName, 'aggregate')
         this.featAggregate = new Aggregate(agentRef, argsObjFromInstrument)
+
+        agentRef.runtime.harvester.initializedAggregates.push(this.featAggregate) // "subscribe" the feature to future harvest intervals (PVE will start the timer)
         loadedSuccessfully(true)
       } catch (e) {
         warn(34, e)

package/src/loaders/api/api-methods.js

@@ -1,7 +1,7 @@
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants'
 
 export const apiMethods = [
-  'setErrorHandler', 'finished', 'addToTrace', 'addRelease',
+  'setErrorHandler', 'finished', 'addToTrace', 'addRelease', 'recordCustomEvent',
   'addPageAction', 'setCurrentRouteName', 'setPageViewName', 'setCustomAttribute',
   'interaction', 'noticeError', 'setUserId', 'setApplicationVersion', 'start',
   SR_EVENT_EMITTER_TYPES.RECORD, SR_EVENT_EMITTER_TYPES.PAUSE, 'log', 'wrapLogger'

package/src/loaders/api/api.js

@@ -72,6 +72,8 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
 
   apiInterface.addPageAction = apiCall(prefix, 'addPageAction', true, FEATURE_NAMES.genericEvents)
 
+  apiInterface.recordCustomEvent = apiCall(prefix, 'recordCustomEvent', true, FEATURE_NAMES.genericEvents)
+
   apiInterface.setPageViewName = function (name, host) {
     if (typeof name !== 'string') return
     if (name.charAt(0) !== '/') name = '/' + name
@@ -192,7 +194,7 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
   function apiCall (prefix, name, notSpa, bufferGroup) {
     return function () {
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/' + name + '/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
-      if (bufferGroup) handle(prefix + name, [now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE) // no bufferGroup means only the SM is emitted
+      if (bufferGroup) handle(prefix + name, [notSpa ? now() : performance.now(), ...arguments], notSpa ? null : this, bufferGroup, instanceEE) // no bufferGroup means only the SM is emitted
       return notSpa ? undefined : this // returns the InteractionHandle which allows these methods to be chained
     }
   }

package/src/loaders/features/features.js

@@ -1,7 +1,13 @@
+// To reduce build size a bit:
+export const EVENTS = 'events'
+export const JSERRORS = 'jserrors'
+const BLOBS = 'browser/blobs'
+export const RUM = 'rum'
+
 export const FEATURE_NAMES = {
   ajax: 'ajax',
   genericEvents: 'generic_events',
-  jserrors: 'jserrors',
+  jserrors: JSERRORS,
   logging: 'logging',
   metrics: 'metrics',
   /**
@@ -35,14 +41,15 @@ export const featurePriority = {
 }
 
 export const FEATURE_TO_ENDPOINT = {
-  [FEATURE_NAMES.pageViewTiming]: 'events',
-  [FEATURE_NAMES.ajax]: 'events',
-  [FEATURE_NAMES.spa]: 'events',
-  [FEATURE_NAMES.softNav]: 'events',
-  [FEATURE_NAMES.metrics]: 'jserrors',
-  [FEATURE_NAMES.jserrors]: 'jserrors',
-  [FEATURE_NAMES.sessionTrace]: 'browser/blobs',
-  [FEATURE_NAMES.sessionReplay]: 'browser/blobs',
+  [FEATURE_NAMES.pageViewEvent]: RUM,
+  [FEATURE_NAMES.pageViewTiming]: EVENTS,
+  [FEATURE_NAMES.ajax]: EVENTS,
+  [FEATURE_NAMES.spa]: EVENTS,
+  [FEATURE_NAMES.softNav]: EVENTS,
+  [FEATURE_NAMES.metrics]: JSERRORS,
+  [FEATURE_NAMES.jserrors]: JSERRORS,
+  [FEATURE_NAMES.sessionTrace]: BLOBS,
+  [FEATURE_NAMES.sessionReplay]: BLOBS,
   [FEATURE_NAMES.logging]: 'browser/logs',
   [FEATURE_NAMES.genericEvents]: 'ins'
 }

package/src/loaders/micro-agent-base.js

@@ -30,6 +30,16 @@ export class MicroAgentBase {
     return this.#callMethod('addPageAction', name, attributes)
   }
 
+  /**
+   * Records a custom event with a specified eventType and attributes.
+   * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/recordCustomEvent/}
+   * @param {string} eventType The eventType to store the event as.
+   * @param {object} [attributes] JSON object with one or more key/value pairs. For example: {key:"value"}.
+   */
+  recordCustomEvent (eventType, attributes) {
+    return this.#callMethod('recordCustomEvent', eventType, attributes)
+  }
+
   /**
    * Groups page views to help URL structure or to capture the URL's routing information.
    * {@link https://docs.newrelic.com/docs/browser/new-relic-browser/browser-apis/setpageviewname/}

package/src/loaders/micro-agent.js

@@ -64,6 +64,7 @@ export class MicroAgent extends MicroAgentBase {
                 return lazyFeatureLoader(f, 'aggregate')
               }).then(({ Aggregate }) => {
                 this.features[f] = new Aggregate(this)
+                this.runtime.harvester.initializedAggregates.push(this.features[f]) // so that harvester will poll this feature agg on interval
               }).catch(err => warn(25, err))
             }
           })

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

@@ -1,168 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.HarvestScheduler = void 0;
-var submitData = _interopRequireWildcard(require("../util/submit-data"));
-var _sharedContext = require("../context/shared-context");
-var _harvest = require("./harvest");
-var _eol = require("../unload/eol");
-var _constants = require("../session/constants");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * Periodically invokes harvest calls and handles retries
- */
-class HarvestScheduler extends _sharedContext.SharedContext {
-  /**
-     * Create a HarvestScheduler
-     * @param {string} endpoint - The base BAM endpoint name -- ex. 'events'
-     * @param {object} opts - The options used to configure the HarvestScheduler
-     * @param {Function} opts.onFinished - The callback to be fired when a harvest has finished
-     * @param {Function} opts.getPayload - A callback which can be triggered to return a payload for harvesting
-     * @param {number} opts.retryDelay - The number of seconds to wait before retrying after a network failure
-     * @param {boolean} opts.raw - Use a prefabricated payload shape as the harvest payload without the need for formatting
-     * @param {string} opts.customUrl - A custom url that falls outside of the shape of the standard BAM harvester url pattern.  Will use directly instead of concatenating various pieces
-     * @param {*} parent - The parent object, whose state can be passed into SharedContext
-     */
-  constructor(endpoint, opts, parent) {
-    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
-    this.endpoint = endpoint;
-    this.opts = opts || {};
-    this.started = false;
-    this.timeoutHandle = null;
-    this.aborted = false; // this controls the per-interval and final harvests for the scheduler (currently per feature specific!)
-    this.harvesting = false;
-    this.harvest = new _harvest.Harvest(this.sharedContext);
-
-    // If a feature specifies stuff to be done on page unload, those are frontrunned (via capture phase) before ANY feature final harvests.
-    if (typeof this.opts.onUnload === 'function') (0, _eol.subscribeToEOL)(this.opts.onUnload, true);
-    (0, _eol.subscribeToEOL)(this.unload.bind(this)); // this should consist only of sending final harvest
-
-    /* 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(_constants.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;
-    this.runHarvest({
-      unload: true
-    });
-  }
-  startTimer(interval, initialDelay) {
-    this.interval = interval;
-    this.started = true;
-    this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval);
-  }
-  stopTimer(permanently = false) {
-    this.aborted = permanently; // stopping permanently is same as aborting, but this function also cleans up the setTimeout loop
-    this.started = false;
-    if (this.timeoutHandle) {
-      clearTimeout(this.timeoutHandle);
-    }
-  }
-  scheduleHarvest(delay, opts) {
-    if (this.timeoutHandle) return;
-    if (delay == null) {
-      delay = this.interval;
-    }
-    this.timeoutHandle = setTimeout(() => {
-      this.timeoutHandle = null;
-      this.runHarvest(opts);
-    }, delay * 1000);
-  }
-  runHarvest(opts) {
-    if (this.aborted) return;
-    this.harvesting = true;
-
-    /**
-     * 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 => {
-      this.harvesting = false;
-      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, Softnav, Logging, SR & ST features provide a single callback function to get data for harvesting
-      submitMethod = submitData.getSubmitMethod({
-        isFinalHarvest: opts?.unload
-      });
-      if (!submitMethod) return false;
-      const retry = !opts?.unload && submitMethod === submitData.xhr;
-      payload = this.opts.getPayload({
-        retry,
-        ...opts
-      });
-      if (!payload) {
-        if (this.started) {
-          this.scheduleHarvest();
-        }
-        return;
-      }
-      payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload];
-      harvests.push(...payload);
-    }
-
-    /** sendX is used for features that do not supply a preformatted payload via "getPayload" */
-    let send = args => this.harvest.sendX(args);
-    if (harvests.length) {
-      /** _send is the underlying method for sending in the harvest, if sending raw we can bypass the other helpers completely which format the payloads */
-      if (this.opts.raw) send = args => this.harvest._send(args);
-      /** send is used to formated the payloads from "getPayload" and obfuscate before sending */else send = args => this.harvest.send(args);
-    } else {
-      // force it to run at least once in sendX mode
-      harvests.push(undefined);
-    }
-    harvests.forEach(payload => {
-      send({
-        endpoint: this.endpoint,
-        payload,
-        opts,
-        submitMethod,
-        cbFinished: cbRanAfterSend,
-        customUrl: this.opts.customUrl,
-        raw: this.opts.raw
-      });
-    });
-    if (this.started) {
-      this.scheduleHarvest();
-    }
-  }
-  onHarvestFinished(opts, result) {
-    if (this.opts.onFinished) {
-      this.opts.onFinished(result);
-    }
-    if (result.sent && result.retry) {
-      const delay = result.delay || this.opts.retryDelay;
-      // reschedule next harvest if should be delayed longer
-      if (this.started && delay) {
-        clearTimeout(this.timeoutHandle);
-        this.timeoutHandle = null;
-        this.scheduleHarvest(delay, opts);
-      } else if (!this.started && delay) {
-        // if not running on a timer, schedule a single retry
-        this.scheduleHarvest(delay, opts);
-      }
-    }
-  }
-}
-exports.HarvestScheduler = HarvestScheduler;