@newrelic/browser-agent 1.276.0 → 1.278.0

package/dist/cjs/features/logging/aggregate/index.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.Aggregate = void 0;
 var _handle = require("../../../common/event-emitter/handle");
 var _registerHandler = require("../../../common/event-emitter/register-handler");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _console = require("../../../common/util/console");
 var _stringify = require("../../../common/util/stringify");
 var _constants = require("../../metrics/constants");
@@ -16,24 +15,17 @@ var _log = require("../shared/log");
 var _utils = require("../shared/utils");
 var _traverse = require("../../../common/util/traverse");
 var _agentConstants = require("../../../common/constants/agent-constants");
-var _features = require("../../../loaders/features/features");
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants2.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants2.FEATURE_NAME);
-    this.harvestTimeSeconds = agentRef.init.logging.harvestTimeSeconds;
+    this.harvestOpts.raw = true;
     this.waitForFlags([]).then(() => {
-      this.scheduler = new _harvestScheduler.HarvestScheduler(_features.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);
       /** emitted by instrument class (wrapped loggers) or the api methods directly */
       (0, _registerHandler.registerHandler)(_constants2.LOGGING_EVENT_EMITTER_CHANNEL, this.handleLog.bind(this), this.featureName, this.ee);
       this.drain();
       /** harvest immediately once started to purge pre-load logs collected */
-      this.scheduler.startTimer(this.harvestTimeSeconds, 0);
+      agentRef.runtime.harvester.triggerHarvestFor(this);
     });
   }
   handleLog(timestamp, message, attributes = {}, level = _constants2.LOG_LEVELS.INFO) {
@@ -67,8 +59,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       return;
     }
     if (this.events.wouldExceedMaxSize(logBytes)) {
-      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.events.bytes + logBytes]);
-      this.scheduler.runHarvest(); // force a harvest to try adding again
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.events.byteSize() + logBytes]);
+      this.agentRef.runtime.harvester.triggerHarvestFor(this); // force a harvest synchronously to try adding again
     }
     if (!this.events.add(log)) {
       // still failed after a harvest attempt despite not being too large would mean harvest failed with options.retry

package/dist/cjs/features/metrics/aggregate/index.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _constants = require("../constants");
 var _frameworkDetection = require("./framework-detection");
 var _protocol = require("../../../common/url/protocol");
@@ -13,7 +12,6 @@ var _load = require("../../../common/window/load");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _runtime = require("../../../common/constants/runtime");
 var _aggregateBase = require("../../utils/aggregate-base");
-var _features = require("../../../loaders/features/features");
 var _iframe = require("../../../common/dom/iframe");
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
@@ -22,18 +20,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
-    const aggregatorTypes = ['cm', 'sm']; // the types in EventAggregator this feature cares about
+    this.harvestOpts.aggregatorTypes = ['cm', 'sm']; // the types in EventAggregator this feature cares about
+    // This feature only harvests once per potential EoL of the page, which is handled by the central harvester.
 
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
-        const scheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
-          onUnload: () => this.unload()
-        }, this);
-        // this is needed to ensure EoL is "on" and sent
-        scheduler.harvest.on(_features.FEATURE_TO_ENDPOINT[this.featureName], () => this.makeHarvestPayload(undefined, {
-          aggregatorTypes
-        }));
         this.drain();
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -47,6 +38,10 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.singleChecks(); // checks that are run only one time, at script load
     this.eachSessionChecks(); // the start of every time user engages with page
   }
+  preHarvestChecks() {
+    return this.drained;
+  } // only allow any metrics to be sent if we know for sure it has gotten the go-ahead RUM flag
+
   storeSupportabilityMetrics(name, value) {
     if (this.blocked) return;
     const type = _constants.SUPPORTABILITY_METRIC;
@@ -61,7 +56,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const params = {
       name
     };
-    this.events.add(type, name, params, metrics);
+    this.events.add([type, name, params, metrics]);
   }
   singleChecks() {
     // report loaderType
@@ -153,8 +148,5 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }
     });
   }
-  unload() {
-    // do nothing for now, marks and measures and resources stats are now being captured by the ge feature
-  }
 }
 exports.Aggregate = Aggregate;

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

@@ -8,7 +8,6 @@ var _runtime = require("../../../common/constants/runtime");
 var _navTiming = require("../../../common/timing/nav-timing");
 var _stringify = require("../../../common/util/stringify");
 var _info = require("../../../common/config/info");
-var _harvest = require("../../../common/harvest/harvest");
 var CONSTANTS = _interopRequireWildcard(require("../constants"));
 var _initializedFeatures = require("./initialized-features");
 var _featureFlags = require("../../../common/util/feature-flags");
@@ -29,11 +28,12 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.timeToFirstByte = 0;
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
-    this.timeKeeper = new _timeKeeper.TimeKeeper(agentRef.agentIdentifier);
+
     if (!(0, _info.isValid)(agentRef.agentIdentifier)) {
       this.ee.abort();
       return (0, _console.warn)(43);
     }
+    agentRef.runtime.timeKeeper = new _timeKeeper.TimeKeeper(agentRef.agentIdentifier);
     if (_runtime.isBrowserScope) {
       _timeToFirstByte.timeToFirstByte.subscribe(({
         value,
@@ -53,7 +53,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }
   sendRum() {
     const info = this.agentRef.info;
-    const harvester = new _harvest.Harvest(this);
     const measures = {};
     if (info.queueTime) measures.qt = info.queueTime;
     if (info.applicationTime) measures.ap = info.applicationTime;
@@ -103,54 +102,53 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
     queryParameters.fp = _firstPaint.firstPaint.current.value;
     queryParameters.fcp = _firstContentfulPaint.firstContentfulPaint.current.value;
-    if (this.timeKeeper?.ready) {
-      queryParameters.timestamp = Math.floor(this.timeKeeper.correctRelativeTimestamp((0, _now.now)()));
+    const timeKeeper = this.agentRef.runtime.timeKeeper;
+    if (timeKeeper?.ready) {
+      queryParameters.timestamp = Math.floor(timeKeeper.correctRelativeTimestamp((0, _now.now)()));
     }
-    const rumStartTime = (0, _now.now)();
-    harvester.send({
-      endpoint: 'rum',
-      payload: {
-        qs: queryParameters,
-        body
-      },
-      opts: {
-        needResponse: true,
-        sendEmptyBody: true
-      },
-      cbFinished: ({
-        status,
-        responseText,
-        xhr
-      }) => {
-        const rumEndTime = (0, _now.now)();
-        if (status >= 400 || status === 0) {
-          // Adding retry logic for the rum call will be a separate change
-          this.ee.abort();
-          return;
+    this.rumStartTime = (0, _now.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();
-            (0, _console.warn)(17, error);
-            return;
-          }
-          this.agentRef.runtime.appMetadata = app;
-          (0, _featureFlags.activateFeatures)(flags, this.agentIdentifier);
-          this.drain();
-        } catch (err) {
-          this.ee.abort();
-          (0, _console.warn)(18, err);
-        }
-      }
+      },
+      needResponse: true,
+      sendEmptyBody: true
     });
   }
+  postHarvestCleanup({
+    status,
+    responseText,
+    xhr
+  }) {
+    const rumEndTime = (0, _now.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) {
+      (0, _console.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();
+      (0, _console.warn)(17, error);
+      return;
+    }
+    this.agentRef.runtime.appMetadata = app;
+    (0, _featureFlags.activateFeatures)(flags, this.agentIdentifier);
+    this.drain();
+    this.agentRef.runtime.harvester.startTimer();
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Aggregate = void 0;
 var _belSerializer = require("../../../common/serialize/bel-serializer");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _handle = require("../../../common/event-emitter/handle");
 var _constants = require("../constants");
@@ -40,10 +39,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.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:
     (0, _registerHandler.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.firstPaint.subscribe(this.#handleVitalMetric);
       _firstContentfulPaint.firstContentfulPaint.subscribe(this.#handleVitalMetric);
       _firstInputDelay.firstInputDelay.subscribe(this.#handleVitalMetric);
@@ -67,11 +63,6 @@ class Aggregate extends _aggregateBase.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.HarvestScheduler(_features.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/cjs/features/session_replay/aggregate/index.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _constants = require("../constants");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _sharedChannel = require("../../../common/constants/shared-channel");
@@ -37,8 +36,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
   // pass the recorder into the aggregator
   constructor(agentRef, args) {
     super(agentRef, _constants.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 */
@@ -54,6 +51,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.timeKeeper = undefined;
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
+    this.harvestOpts.raw = true;
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, _features.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.
@@ -78,19 +76,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (this.mode !== _constants3.MODE.OFF && data.sessionReplayMode === _constants3.MODE.OFF) this.abort(_constants.ABORT_REASONS.CROSS_TAB);
       this.mode = data.sessionReplay;
     });
-
-    // Bespoke logic for blobs endpoint.
-    this.scheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
-      onFinished: result => this.postHarvestCleanup(result),
-      retryDelay: this.harvestTimeSeconds,
-      getPayload: ({
-        retry,
-        ...opts
-      }) => this.makeHarvestPayload(retry, opts),
-      raw: true
-    }, this);
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.PAUSE, () => {
-      this.forceStop(this.mode !== _constants3.MODE.ERROR);
+      this.forceStop(this.mode === _constants3.MODE.FULL);
     }, this.featureName, this.ee);
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
       this.handleError(e);
@@ -136,7 +123,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/ErrorSamplingRate/Value', error_sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
   }
   replayIsActive() {
-    return Boolean(this.scheduler?.started && this.recorder && this.mode === _constants3.MODE.FULL && !this.blocked && this.entitled);
+    return Boolean(this.recorder && this.mode === _constants3.MODE.FULL && !this.blocked && this.entitled);
   }
   handleError(e) {
     if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
@@ -151,20 +138,17 @@ class Aggregate extends _aggregateBase.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(_constants3.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}
    */
@@ -211,20 +195,14 @@ class Aggregate extends _aggregateBase.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 === _constants3.MODE.ERROR && this.errorNoticed) this.mode = _constants3.MODE.FULL;
-    if (this.mode === _constants3.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 === _constants3.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();
@@ -245,11 +223,12 @@ class Aggregate extends _aggregateBase.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 !== _constants3.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 !== _constants3.MODE.FULL || this.blocked) return;
+    if (!recorderEvents.events.length) return;
     const payload = this.getHarvestContents(recorderEvents);
     if (!payload.body.length) {
       this.recorder.clearBuffer();
@@ -273,7 +252,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
         return (0, _stringify.stringify)(output);
       }).join(','), "]")));
       len = payload.body.length;
-      this.scheduler.opts.gzip = true;
     } else {
       payload.body = payload.body.map(({
         __serialized,
@@ -288,7 +266,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
         return output;
       });
       len = (0, _stringify.stringify)(payload.body).length;
-      this.scheduler.opts.gzip = false;
     }
     if (len > _agentConstants.MAX_PAYLOAD_SIZE) {
       this.abort(_constants.ABORT_REASONS.TOO_BIG, len);
@@ -299,8 +276,11 @@ class Aggregate extends _aggregateBase.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;
@@ -386,7 +366,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (result.status === 429) {
       this.abort(_constants.ABORT_REASONS.TOO_MANY);
     }
-    if (this.blocked) this.scheduler.stopTimer(true);
   }
 
   /**
@@ -395,7 +374,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
    * the stopRecording API.
    */
   forceStop(forceHarvest) {
-    if (forceHarvest) this.scheduler.runHarvest();
+    if (forceHarvest) this.agentRef.runtime.harvester.triggerHarvestFor(this);
     this.mode = _constants3.MODE.OFF;
     this.recorder?.stopRecording?.();
     this.syncWithSessionManager({
@@ -414,7 +393,6 @@ class Aggregate extends _aggregateBase.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/cjs/features/session_replay/instrument/index.js

@@ -84,7 +84,8 @@ class Instrument extends _instrumentBase.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/cjs/features/session_replay/shared/recorder.js

@@ -7,7 +7,6 @@ exports.Recorder = void 0;
 var _rrweb = require("rrweb");
 var _stringify = require("../../../common/util/stringify");
 var _constants = require("../constants");
-var _init = require("../../../common/config/init");
 var _recorderEvents = require("./recorder-events");
 var _constants2 = require("../../../common/session/constants");
 var _stylesheetEvaluator = require("./stylesheet-evaluator");
@@ -16,6 +15,7 @@ var _constants3 = require("../../metrics/constants");
 var _features = require("../../../loaders/features/features");
 var _utils = require("./utils");
 var _agentConstants = require("../../../common/constants/agent-constants");
+var _aggregateBase = require("../../utils/aggregate-base");
 class Recorder {
   /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
   #events;
@@ -40,7 +40,7 @@ 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 = (0, _init.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 */};
   }
@@ -84,7 +84,7 @@ class Recorder {
       mask_all_inputs,
       inline_images,
       collect_fonts
-    } = (0, _init.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;
@@ -160,7 +160,7 @@ 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.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(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
@@ -198,8 +198,8 @@ 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 === _constants.RRWEB_EVENT_TYPES.FullSnapshot && this.currentBufferTarget.hasMeta || payloadSize > _agentConstants.IDEAL_PAYLOAD_SIZE) && this.parent.mode === _constants2.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.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.RecorderEvents());

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _constants = require("../constants");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _storage = require("./trace/storage");
@@ -13,7 +12,6 @@ var _encode = require("../../../common/url/encode");
 var _runtime = require("../../../common/constants/runtime");
 var _constants2 = require("../../../common/session/constants");
 var _traverse = require("../../../common/util/traverse");
-var _features = require("../../../loaders/features/features");
 var _cleanUrl = require("../../../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 */
@@ -22,7 +20,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.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 */
@@ -31,14 +30,16 @@ class Aggregate extends _aggregateBase.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 _storage.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 */
@@ -56,7 +57,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
         // this will only have an effect if ST is NOT already in full mode
         if (this.mode !== _constants2.MODE.FULL && (sessionState.sessionReplayMode === _constants2.MODE.FULL || sessionState.sessionTraceMode === _constants2.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 === _constants2.MODE.OFF) this.abort(2);
+        if (this.sessionId !== sessionState.value || eventType === 'cross-tab' && sessionState.sessionTraceMode === _constants2.MODE.OFF) this.abort(2);
       });
       if (typeof PerformanceNavigationTiming !== 'undefined') {
         this.events.storeTiming(_runtime.globalScope.performance?.getEntriesByType?.('navigation')[0]);
@@ -73,12 +74,6 @@ class Aggregate extends _aggregateBase.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 === _constants2.MODE.OFF) return this.deregisterDrain();
     this.timeKeeper ??= this.agentRef.runtime.timeKeeper;
-    this.scheduler = new _harvestScheduler.HarvestScheduler(_features.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 */
     (0, _registerHandler.registerHandler)('bst', (...args) => this.events.storeEvent(...args), this.featureName, this.ee);
@@ -88,9 +83,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)('bstApi', (...args) => this.events.storeSTN(...args), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('trace-jserror', (...args) => this.events.storeErrorAgg(...args), this.featureName, this.ee);
     (0, _registerHandler.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 === _constants2.MODE.FULL) this.startHarvesting();else {
+    if (this.mode !== _constants2.MODE.FULL) {
       /** A separate handler for noticing errors, and switching to "full" mode if running in "error" mode */
       (0, _registerHandler.registerHandler)('trace-jserror', () => {
         if (this.mode === _constants2.MODE.ERROR) this.switchToFull();
@@ -101,13 +94,6 @@ class Aggregate extends _aggregateBase.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 !== _constants2.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
@@ -198,8 +184,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (prevMode === _constants2.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 */
@@ -209,7 +195,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.agentRef.runtime.session.write({
       sessionTraceMode: this.mode
     });
-    this.scheduler?.stopTimer();
     this.events.clear();
   }
 }

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

@@ -275,14 +275,20 @@ class TraceStorage {
     this.storeSTN(new _node.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;