@newrelic/browser-agent 1.277.0 → 1.278.1

package/dist/esm/features/page_view_event/aggregate/index.js

@@ -2,7 +2,6 @@ import { globalScope, isBrowserScope, originTime } from '../../../common/constan
 import { addPT, addPN } from '../../../common/timing/nav-timing';
 import { stringify } from '../../../common/util/stringify';
 import { isValid } from '../../../common/config/info';
-import { Harvest } from '../../../common/harvest/harvest';
 import * as CONSTANTS from '../constants';
 import { getActivatedFeaturesFlags } from './initialized-features';
 import { activateFeatures } from '../../../common/util/feature-flags';
@@ -21,11 +20,12 @@ export class Aggregate extends AggregateBase {
     this.timeToFirstByte = 0;
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
-    this.timeKeeper = new TimeKeeper(agentRef.agentIdentifier);
+
     if (!isValid(agentRef.agentIdentifier)) {
       this.ee.abort();
       return warn(43);
     }
+    agentRef.runtime.timeKeeper = new TimeKeeper(agentRef.agentIdentifier);
     if (isBrowserScope) {
       timeToFirstByte.subscribe(({
         value,
@@ -45,7 +45,6 @@ export class Aggregate extends AggregateBase {
   }
   sendRum() {
     const info = this.agentRef.info;
-    const harvester = new Harvest(this);
     const measures = {};
     if (info.queueTime) measures.qt = info.queueTime;
     if (info.applicationTime) measures.ap = info.applicationTime;
@@ -95,53 +94,52 @@ export class Aggregate extends AggregateBase {
     }
     queryParameters.fp = firstPaint.current.value;
     queryParameters.fcp = firstContentfulPaint.current.value;
-    if (this.timeKeeper?.ready) {
-      queryParameters.timestamp = Math.floor(this.timeKeeper.correctRelativeTimestamp(now()));
+    const timeKeeper = this.agentRef.runtime.timeKeeper;
+    if (timeKeeper?.ready) {
+      queryParameters.timestamp = Math.floor(timeKeeper.correctRelativeTimestamp(now()));
     }
-    const rumStartTime = now();
-    harvester.send({
-      endpoint: 'rum',
-      payload: {
-        qs: queryParameters,
-        body
-      },
-      opts: {
-        needResponse: true,
-        sendEmptyBody: true
-      },
-      cbFinished: ({
-        status,
-        responseText,
-        xhr
-      }) => {
-        const rumEndTime = now();
-        if (status >= 400 || status === 0) {
-          // Adding retry logic for the rum call will be a separate change
-          this.ee.abort();
-          return;
+    this.rumStartTime = now();
+    this.agentRef.runtime.harvester.triggerHarvestFor(this, {
+      directSend: {
+        targetApp: this.agentRef.mainAppKey,
+        payload: {
+          qs: queryParameters,
+          body
         }
-        try {
-          const {
-            app,
-            ...flags
-          } = JSON.parse(responseText);
-          try {
-            this.timeKeeper.processRumRequest(xhr, rumStartTime, rumEndTime, app.nrServerTime);
-            if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready');
-            this.agentRef.runtime.timeKeeper = this.timeKeeper;
-          } catch (error) {
-            this.ee.abort();
-            warn(17, error);
-            return;
-          }
-          this.agentRef.runtime.appMetadata = app;
-          activateFeatures(flags, this.agentIdentifier);
-          this.drain();
-        } catch (err) {
-          this.ee.abort();
-          warn(18, err);
-        }
-      }
+      },
+      needResponse: true,
+      sendEmptyBody: true
     });
   }
+  postHarvestCleanup({
+    status,
+    responseText,
+    xhr
+  }) {
+    const rumEndTime = now();
+    this.blocked = true; // this prevents harvester from polling this feature's event buffer (DNE) on interval; in other words, harvests will skip PVE
+
+    if (status >= 400 || status === 0) {
+      warn(18, status);
+      // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
+      this.ee.abort();
+      return;
+    }
+    const {
+      app,
+      ...flags
+    } = JSON.parse(responseText);
+    try {
+      this.agentRef.runtime.timeKeeper.processRumRequest(xhr, this.rumStartTime, rumEndTime, app.nrServerTime);
+      if (!this.agentRef.runtime.timeKeeper.ready) throw new Error('TimeKeeper not ready');
+    } catch (error) {
+      this.ee.abort();
+      warn(17, error);
+      return;
+    }
+    this.agentRef.runtime.appMetadata = app;
+    activateFeatures(flags, this.agentIdentifier);
+    this.drain();
+    this.agentRef.runtime.harvester.startTimer();
+  }
 }

package/dist/esm/features/page_view_timing/aggregate/index.js

@@ -4,11 +4,10 @@
  */
 
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { handle } from '../../../common/event-emitter/handle';
 import { FEATURE_NAME } 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 { cumulativeLayoutShift } from '../../../common/vitals/cumulative-layout-shift';
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint';
@@ -34,10 +33,7 @@ export class Aggregate extends AggregateBase {
     registerHandler('docHidden', msTimestamp => this.endCurrentSession(msTimestamp), this.featureName, this.ee);
     // Add the time of _window pagehide event_ firing to the next PVT harvest == NRDB windowUnload attr:
     registerHandler('winPagehide', msTimestamp => this.addTiming('unload', msTimestamp, null), this.featureName, this.ee);
-    const harvestTimeSeconds = agentRef.init.page_view_timing.harvestTimeSeconds || 30;
     this.waitForFlags([]).then(() => {
-      /* It's important that CWV api, like "onLCP", is called before the **scheduler** is initialized. The reason is because they listen to the same
-        on vis change or pagehide events, and we'd want ex. onLCP to record the timing (win the race) before we try to send "final harvest". */
       firstPaint.subscribe(this.#handleVitalMetric);
       firstContentfulPaint.subscribe(this.#handleVitalMetric);
       firstInputDelay.subscribe(this.#handleVitalMetric);
@@ -61,11 +57,6 @@ export class Aggregate extends AggregateBase {
         this.addTiming(name, value * 1000, attrs);
       }, true); // CLS node should only reports on vis change rather than on every change
 
-      const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-        onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
-        getPayload: options => this.makeHarvestPayload(options.retry)
-      }, this);
-      scheduler.startTimer(harvestTimeSeconds);
       this.drain();
     });
   }

package/dist/esm/features/session_replay/aggregate/index.js

@@ -7,7 +7,6 @@
  */
 
 import { registerHandler } from '../../../common/event-emitter/register-handler';
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { ABORT_REASONS, FEATURE_NAME, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { sharedChannel } from '../../../common/constants/shared-channel';
@@ -16,7 +15,7 @@ import { warn } from '../../../common/util/console';
 import { globalScope } from '../../../common/constants/runtime';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { handle } from '../../../common/event-emitter/handle';
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { RRWEB_VERSION } from "../../../common/constants/env.npm";
 import { MODE, SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/session/constants';
 import { stringify } from '../../../common/util/stringify';
@@ -32,8 +31,6 @@ export class Aggregate extends AggregateBase {
   // pass the recorder into the aggregator
   constructor(agentRef, args) {
     super(agentRef, FEATURE_NAME);
-    /** The interval to harvest at.  This gets overridden if the size of the payload exceeds certain thresholds */
-    this.harvestTimeSeconds = agentRef.init.session_replay.harvestTimeSeconds || 60;
     /** Set once the recorder has fully initialized after flag checks and sampling */
     this.initialized = false;
     /** Set once the feature has been "aborted" to prevent other side-effects from continuing */
@@ -49,6 +46,7 @@ export class Aggregate extends AggregateBase {
     this.timeKeeper = undefined;
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
+    this.harvestOpts.raw = true;
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee);
 
     // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
@@ -73,19 +71,8 @@ export class Aggregate extends AggregateBase {
       if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);
       this.mode = data.sessionReplay;
     });
-
-    // Bespoke logic for blobs endpoint.
-    this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-      onFinished: result => this.postHarvestCleanup(result),
-      retryDelay: this.harvestTimeSeconds,
-      getPayload: ({
-        retry,
-        ...opts
-      }) => this.makeHarvestPayload(retry, opts),
-      raw: true
-    }, this);
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
-      this.forceStop(this.mode !== MODE.ERROR);
+      this.forceStop(this.mode === MODE.FULL);
     }, this.featureName, this.ee);
     registerHandler(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
       this.handleError(e);
@@ -131,7 +118,7 @@ export class Aggregate extends AggregateBase {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
   }
   replayIsActive() {
-    return Boolean(this.scheduler?.started && this.recorder && this.mode === MODE.FULL && !this.blocked && this.entitled);
+    return Boolean(this.recorder && this.mode === MODE.FULL && !this.blocked && this.entitled);
   }
   handleError(e) {
     if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
@@ -146,20 +133,17 @@ export class Aggregate extends AggregateBase {
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
       if (!this.recorder.recording) this.recorder.startRecording();
-      this.scheduler.startTimer(this.harvestTimeSeconds);
       this.syncWithSessionManager({
         sessionReplayMode: this.mode
       });
     } else {
-      this.initializeRecording(false, true, true);
+      this.initializeRecording(MODE.FULL, true);
     }
   }
 
   /**
    * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
    * @param {boolean} entitlements - the true/false state of the "sr" flag from RUM response
-   * @param {boolean} errorSample - the true/false state of the error sampling decision
-   * @param {boolean} fullSample - the true/false state of the full sampling decision
    * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
    * @returns {void}
    */
@@ -206,20 +190,14 @@ export class Aggregate extends AggregateBase {
 
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
     if (this.mode === MODE.ERROR && this.errorNoticed) this.mode = MODE.FULL;
-    if (this.mode === MODE.FULL) {
-      // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
-      if (this.recorder?.getEvents().type === 'preloaded') {
-        this.prepUtils().then(() => {
-          this.scheduler.runHarvest();
-        });
-      }
-      // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
-      // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
-      // If an error happened in ERROR mode before we've gotten to this stage, it will have already set the mode to FULL
-      if (!this.scheduler.started) {
-        // We only report (harvest) in FULL mode
-        this.scheduler.startTimer(this.harvestTimeSeconds);
-      }
+
+    // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
+    // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
+    // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
+
+    // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
+    if (this.mode === MODE.FULL && this.recorder?.getEvents().type === 'preloaded') {
+      this.prepUtils().then(() => this.agentRef.runtime.harvester.triggerHarvestFor(this));
     }
     await this.prepUtils();
     if (!this.recorder.recording) this.recorder.startRecording();
@@ -240,11 +218,12 @@ export class Aggregate extends AggregateBase {
       // compressor failed to load, but we can still record without compression as a last ditch effort
     }
   }
-  makeHarvestPayload(shouldRetryOnFail, opts) {
+  makeHarvestPayload(shouldRetryOnFail) {
+    if (this.mode !== MODE.FULL || this.blocked) return;
     if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return;
     const recorderEvents = this.recorder.getEvents();
     // get the event type and use that to trigger another harvest if needed
-    if (!recorderEvents.events.length || this.mode !== MODE.FULL || this.blocked) return;
+    if (!recorderEvents.events.length) return;
     const payload = this.getHarvestContents(recorderEvents);
     if (!payload.body.length) {
       this.recorder.clearBuffer();
@@ -268,7 +247,6 @@ export class Aggregate extends AggregateBase {
         return stringify(output);
       }).join(','), "]")));
       len = payload.body.length;
-      this.scheduler.opts.gzip = true;
     } else {
       payload.body = payload.body.map(({
         __serialized,
@@ -283,7 +261,6 @@ export class Aggregate extends AggregateBase {
         return output;
       });
       len = stringify(payload.body).length;
-      this.scheduler.opts.gzip = false;
     }
     if (len > MAX_PAYLOAD_SIZE) {
       this.abort(ABORT_REASONS.TOO_BIG, len);
@@ -294,8 +271,11 @@ export class Aggregate extends AggregateBase {
       sessionReplaySentFirstChunk: true
     });
     this.recorder.clearBuffer();
-    if (recorderEvents.type === 'preloaded') this.scheduler.runHarvest(opts);
-    return [payload];
+    if (recorderEvents.type === 'preloaded') this.agentRef.runtime.harvester.triggerHarvestFor(this);
+    return [{
+      targetApp: undefined,
+      payload
+    }]; // SR doesn't need a targetApp as it only works for the main, but format needs to make AggregateBase
   }
   getCorrectedTimestamp(node) {
     if (!node?.timestamp) return;
@@ -381,7 +361,6 @@ export class Aggregate extends AggregateBase {
     if (result.status === 429) {
       this.abort(ABORT_REASONS.TOO_MANY);
     }
-    if (this.blocked) this.scheduler.stopTimer(true);
   }
 
   /**
@@ -390,7 +369,7 @@ export class Aggregate extends AggregateBase {
    * the stopRecording API.
    */
   forceStop(forceHarvest) {
-    if (forceHarvest) this.scheduler.runHarvest();
+    if (forceHarvest) this.agentRef.runtime.harvester.triggerHarvestFor(this);
     this.mode = MODE.OFF;
     this.recorder?.stopRecording?.();
     this.syncWithSessionManager({
@@ -409,7 +388,6 @@ export class Aggregate extends AggregateBase {
       sessionReplayMode: this.mode
     });
     this.recorder?.clearTimestamps?.();
-    this.ee.emit('REPLAY_ABORTED');
     while (this.recorder?.getEvents().events.length) this.recorder?.clearBuffer?.();
   }
   syncWithSessionManager(state = {}) {

package/dist/esm/features/session_replay/instrument/index.js

@@ -79,7 +79,8 @@ export class Instrument extends InstrumentBase {
         mode: this.#mode,
         agentIdentifier: this.agentIdentifier,
         trigger,
-        ee: this.ee
+        ee: this.ee,
+        agentRef: this.#agentRef
       });
       this.recorder.startRecording();
       this.abortHandler = this.recorder.stopRecording;

package/dist/esm/features/session_replay/shared/recorder.js

@@ -1,7 +1,6 @@
 import { record as recorder } from 'rrweb';
 import { stringify } from '../../../common/util/stringify';
 import { AVG_COMPRESSION, CHECKOUT_MS, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES } from '../constants';
-import { getConfigurationValue } from '../../../common/config/init';
 import { RecorderEvents } from './recorder-events';
 import { MODE } from '../../../common/session/constants';
 import { stylesheetEvaluator } from './stylesheet-evaluator';
@@ -10,6 +9,7 @@ import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { buildNRMetaNode } from './utils';
 import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
+import { AggregateBase } from '../../utils/aggregate-base';
 export class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
   #events;
@@ -34,7 +34,7 @@ export class Recorder {
     /** The parent class that instantiated the recorder */
     this.parent = parent;
     /** A flag that can be set to false by failing conversions to stop the fetching process */
-    this.shouldFix = getConfigurationValue(this.parent.agentIdentifier, 'session_replay.fix_stylesheets');
+    this.shouldFix = this.parent.agentRef.init.session_replay.fix_stylesheets;
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     this.stopRecording = () => {/* no-op until set by rrweb initializer */};
   }
@@ -78,7 +78,7 @@ export class Recorder {
       mask_all_inputs,
       inline_images,
       collect_fonts
-    } = getConfigurationValue(this.parent.agentIdentifier, 'session_replay');
+    } = this.parent.agentRef.init.session_replay;
     const customMasker = (text, element) => {
       try {
         if (typeof element?.type === 'string' && element.type.toLowerCase() !== 'password' && (element?.dataset?.nrUnmask !== undefined || element?.classList?.contains('nr-unmask'))) return text;
@@ -154,7 +154,7 @@ export class Recorder {
   /** Store a payload in the buffer (this.#events).  This should be the callback to the recording lib noticing a mutation */
   store(event, isCheckout) {
     if (!event) return;
-    if (!this.parent.scheduler && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
+    if (!(this.parent instanceof AggregateBase) && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
     if (this.parent.blocked) return;
     if (!this.notified) {
       this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
@@ -192,8 +192,8 @@ export class Recorder {
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
     if ((event.type === RRWEB_EVENT_TYPES.FullSnapshot && this.currentBufferTarget.hasMeta || payloadSize > IDEAL_PAYLOAD_SIZE) && this.parent.mode === MODE.FULL) {
       // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
-      if (this.parent.scheduler) {
-        this.parent.scheduler.runHarvest();
+      if (this.parent instanceof AggregateBase) {
+        this.parent.agentRef.runtime.harvester.triggerHarvestFor(this.parent);
       } else {
         // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
         this.#preloaded.push(new RecorderEvents());

package/dist/esm/features/session_trace/aggregate/index.js

@@ -1,5 +1,4 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler';
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { FEATURE_NAME } from '../constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { TraceStorage } from './trace/storage';
@@ -7,7 +6,6 @@ import { obj as encodeObj } from '../../../common/url/encode';
 import { globalScope } from '../../../common/constants/runtime';
 import { MODE, SESSION_EVENTS } from '../../../common/session/constants';
 import { applyFnToProps } from '../../../common/util/traverse';
-import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 import { cleanURL } from '../../../common/url/clean-url';
 const ERROR_MODE_SECONDS_WINDOW = 30 * 1000; // sliding window of nodes to track when simply monitoring (but not harvesting) in error mode
 /** Reserved room for query param attrs */
@@ -16,7 +14,8 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-    this.harvestTimeSeconds = agentRef.init.session_trace.harvestTimeSeconds || 30;
+    this.harvestOpts.raw = true;
+
     /** Tied to the entitlement flag response from BCS.  Will short circuit operations of the agg if false  */
     this.entitled = undefined;
     /** A flag used to decide if the 30 node threshold should be ignored on the first harvest to ensure sending on the first payload */
@@ -25,14 +24,16 @@ export class Aggregate extends AggregateBase {
     this.harvesting = false;
     /** TraceStorage is the mechanism that holds, normalizes and aggregates ST nodes.  It will be accessed and purged when harvests occur */
     this.events = new TraceStorage(this);
-    /** This agg needs information about sampling (sts) and entitlements (st) to make the appropriate decisions on running */
+
+    /* This agg needs information about sampling (sts) and entitlements (st) to make the appropriate decisions on running */
     this.waitForFlags(['sts', 'st']).then(([stMode, stEntitled]) => this.initialize(stMode, stEntitled));
   }
 
   /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
   initialize(stMode, stEntitled, ignoreSession) {
     this.entitled ??= stEntitled;
-    if (this.blocked || !this.entitled) return this.deregisterDrain();
+    if (!this.entitled) this.blocked = true;
+    if (this.blocked) return this.deregisterDrain();
     if (!this.initialized) {
       this.initialized = true;
       /** Store session identifiers at initialization time to be cross-checked later at harvest time for session changes that are subject to race conditions */
@@ -50,7 +51,7 @@ export class Aggregate extends AggregateBase {
         // this will only have an effect if ST is NOT already in full mode
         if (this.mode !== MODE.FULL && (sessionState.sessionReplayMode === MODE.FULL || sessionState.sessionTraceMode === MODE.FULL)) this.switchToFull();
         // if another page's session entity has expired, or another page has transitioned to off and this one hasn't... we can just abort straight away here
-        if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && this.scheduler?.started && sessionState.sessionTraceMode === MODE.OFF) this.abort(2);
+        if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && sessionState.sessionTraceMode === MODE.OFF) this.abort(2);
       });
       if (typeof PerformanceNavigationTiming !== 'undefined') {
         this.events.storeTiming(globalScope.performance?.getEntriesByType?.('navigation')[0]);
@@ -67,12 +68,6 @@ export class Aggregate extends AggregateBase {
      * If it drains later (due to a mode change), data and handlers will instantly drain instead of waiting for the registry. */
     if (this.mode === MODE.OFF) return this.deregisterDrain();
     this.timeKeeper ??= this.agentRef.runtime.timeKeeper;
-    this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-      onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
-      retryDelay: this.harvestTimeSeconds,
-      getPayload: options => this.makeHarvestPayload(options.retry),
-      raw: true
-    }, this);
 
     /** The handlers set up by the Inst file */
     registerHandler('bst', (...args) => this.events.storeEvent(...args), this.featureName, this.ee);
@@ -82,9 +77,7 @@ export class Aggregate extends AggregateBase {
     registerHandler('bstApi', (...args) => this.events.storeSTN(...args), this.featureName, this.ee);
     registerHandler('trace-jserror', (...args) => this.events.storeErrorAgg(...args), this.featureName, this.ee);
     registerHandler('pvtAdded', (...args) => this.events.processPVT(...args), this.featureName, this.ee);
-
-    /** Only start actually harvesting if running in full mode at init time */
-    if (this.mode === MODE.FULL) this.startHarvesting();else {
+    if (this.mode !== MODE.FULL) {
       /** A separate handler for noticing errors, and switching to "full" mode if running in "error" mode */
       registerHandler('trace-jserror', () => {
         if (this.mode === MODE.ERROR) this.switchToFull();
@@ -95,13 +88,6 @@ export class Aggregate extends AggregateBase {
     });
     this.drain();
   }
-
-  /** This module does not auto harvest by default -- it needs to be kicked off.  Once this method is called, it will then harvest on an interval */
-  startHarvesting() {
-    if (this.scheduler.started || this.blocked) return;
-    this.scheduler.runHarvest();
-    this.scheduler.startTimer(this.harvestTimeSeconds);
-  }
   preHarvestChecks() {
     if (this.mode !== MODE.FULL) return; // only allow harvest if running in full mode
     if (!this.timeKeeper?.ready) return; // this should likely never happen, but just to be safe, we should never harvest if we cant correct time
@@ -192,8 +178,8 @@ export class Aggregate extends AggregateBase {
     if (prevMode === MODE.OFF || !this.initialized) return this.initialize(this.mode, this.entitled);
     if (this.initialized) {
       this.events.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // up until now, Trace would've been just buffering nodes up to max, which needs to be trimmed to last X seconds
+      this.agentRef.runtime.harvester.triggerHarvestFor(this);
     }
-    this.startHarvesting();
   }
 
   /** Stop running for the remainder of the page lifecycle */
@@ -203,7 +189,6 @@ export class Aggregate extends AggregateBase {
     this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
-    this.scheduler?.stopTimer();
     this.events.clear();
   }
 }

package/dist/esm/features/session_trace/aggregate/trace/storage.js

@@ -269,14 +269,20 @@ export class TraceStorage {
     this.storeSTN(new TraceNode('Ajax', metrics.time, metrics.time + metrics.duration, "".concat(params.status, " ").concat(params.method, ": ").concat(params.host).concat(params.pathname), 'ajax'));
   }
 
-  /* Below are the interface expected & required of whatever storage is used across all features on an individual basis. This allows a common `.events` property on Trace. */
+  /* Below are the interface expected & required of whatever storage is used across all features on an individual basis. This allows a common `.events` property on Trace shared with AggregateBase.
+    Note that the usage must be in sync with the EventStoreManager class such that AggregateBase.makeHarvestPayload can run the same regardless of which storage class a feature is using. */
   isEmpty() {
     return this.nodeCount === 0;
   }
   save() {
     this.#backupTrace = this.trace;
   }
-  get = this.takeSTNs;
+  get() {
+    return [{
+      targetApp: this.parent.agentRef.mainAppKey,
+      data: this.takeSTNs()
+    }];
+  }
   clear() {
     this.trace = {};
     this.nodeCount = 0;

package/dist/esm/features/soft_navigations/aggregate/index.js

@@ -1,9 +1,8 @@
 import { handle } from '../../../common/event-emitter/handle';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
-import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { single } from '../../../common/util/invoke';
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
-import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { API_TRIGGER_NAME, FEATURE_NAME, INTERACTION_STATUS, INTERACTION_TRIGGERS, IPL_TRIGGER_NAME } from '../constants';
@@ -16,7 +15,6 @@ export class Aggregate extends AggregateBase {
     domObserver
   }) {
     super(agentRef, FEATURE_NAME);
-    const harvestTimeSeconds = agentRef.init.soft_navigations.harvestTimeSeconds || 10;
     this.interactionsToHarvest = this.events;
     this.domObserver = domObserver;
     this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentRef.agentIdentifier);
@@ -37,17 +35,12 @@ export class Aggregate extends AggregateBase {
     this.latestRouteSetByApi = null;
     this.interactionInProgress = null; // aside from the "page load" interaction, there can only ever be 1 ongoing at a time
     this.latestHistoryUrl = null;
-    this.blocked = false;
+    this.harvestOpts.beforeUnload = () => this.interactionInProgress?.done(); // return any withheld ajax or jserr events so they can be sent with EoL harvest
+
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain();
-        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
-          getPayload: options => this.makeHarvestPayload(options.retry),
-          retryDelay: harvestTimeSeconds,
-          onUnload: () => this.interactionInProgress?.done() // return any held ajax or jserr events so they can be sent with EoL harvest
-        }, this);
-        scheduler.startTimer(harvestTimeSeconds, 0);
+        setTimeout(() => agentRef.runtime.harvester.triggerHarvestFor(this), 0); // send the IPL ixn on next tick, giving some time for any ajax to finish; we may want to just remove this?
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
         this.deregisterDrain();
@@ -129,7 +122,7 @@ export class Aggregate extends AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress;
     let saveIxn;
-    const interactionsBuffer = this.interactionsToHarvest.get();
+    const interactionsBuffer = this.interactionsToHarvest.get(this.agentRef.mainAppKey)[0].data;
     for (let idx = interactionsBuffer.length - 1; idx >= 0; idx--) {
       // reverse search for the latest completed interaction for efficiency
       const finishedInteraction = interactionsBuffer[idx];

package/dist/esm/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';
@@ -58,13 +57,11 @@ 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');
     const promiseEE = baseEE.get('promise');
@@ -108,13 +105,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;
@@ -655,8 +649,11 @@ export class Aggregate extends AggregateBase {
       let smCategory;
       if (interaction.root?.attrs?.trigger === 'initialPageLoad') smCategory = 'InitialPageLoad';else if (interaction.routeChange) smCategory = 'RouteChange';else smCategory = 'Custom';
       handle(SUPPORTABILITY_METRIC_CHANNEL, ["Spa/Interaction/".concat(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);
     }
   }
   serializer(eventBuffer) {