@newrelic/browser-agent 1.277.0 → 1.278.0

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.278.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.277.0...v1.278.0) (2025-01-07)
+
+
+### Features
+
+* Centralized harvesting ([#1298](https://github.com/newrelic/newrelic-browser-agent/issues/1298)) ([32c0e3f](https://github.com/newrelic/newrelic-browser-agent/commit/32c0e3f7008423a3e327d17b926d1702d08ae21f))
+
 ## [1.277.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.276.0...v1.277.0) (2024-12-18)
 
 

package/dist/cjs/common/aggregate/event-aggregator.js

@@ -18,7 +18,7 @@ class EventAggregator {
     if (!aggregatorTypes) return Object.keys(this.#aggregator.aggregatedData).length === 0;
     return aggregatorTypes.every(type => !this.#aggregator.aggregatedData[type]); // no bucket exist for any of the types we're looking for
   }
-  add(type, name, params, newMetrics, customParams) {
+  add([type, name, params, newMetrics, customParams]) {
     // Do we need to track byte size here like EventBuffer?
     this.#aggregator.store(type, name, params, newMetrics, customParams);
     return true;

package/dist/cjs/common/config/init.js

@@ -49,7 +49,6 @@ const model = () => {
       deny_list: undefined,
       block_internal: true,
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     distributed_tracing: {
@@ -67,20 +66,17 @@ const model = () => {
     },
     generic_events: {
       enabled: true,
-      harvestTimeSeconds: 30,
       autoStart: true
     },
     harvest: {
-      tooManyRequestsDelay: 60
+      interval: 30
     },
     jserrors: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     logging: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true,
       level: _constants2.LOG_LEVELS.INFO
     },
@@ -98,7 +94,6 @@ const model = () => {
     },
     page_view_timing: {
       enabled: true,
-      harvestTimeSeconds: 30,
       autoStart: true
     },
     performance: {
@@ -146,7 +141,6 @@ const model = () => {
       // feature settings
       autoStart: true,
       enabled: false,
-      harvestTimeSeconds: 60,
       preload: false,
       // if true, enables the agent to load rrweb immediately instead of waiting to do so after the window.load event
       sampling_rate: 10,
@@ -199,17 +193,14 @@ const model = () => {
     },
     session_trace: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     soft_navigations: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     spa: {
       enabled: true,
-      harvestTimeSeconds: 10,
       autoStart: true
     },
     ssl: undefined,

package/dist/cjs/common/config/runtime.js

@@ -34,7 +34,8 @@ const model = {
   session: undefined,
   denyList: undefined,
   timeKeeper: undefined,
-  obfuscator: undefined
+  obfuscator: undefined,
+  harvester: undefined
 };
 const _cache = {};
 function getRuntime(id) {

package/dist/cjs/common/constants/env.cdn.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.277.0";
+const VERSION = exports.VERSION = "1.278.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/env.npm.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.277.0";
+const VERSION = exports.VERSION = "1.278.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/harvest/harvester.js

@@ -0,0 +1,255 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Harvester = void 0;
+var _features = require("../../loaders/features/features");
+var _env = require("../constants/env.npm");
+var _runtime = require("../constants/runtime");
+var _eventListenerOpts = require("../event-listener/event-listener-opts");
+var _constants = require("../session/constants");
+var _now = require("../timing/now");
+var _eol = require("../unload/eol");
+var _cleanUrl = require("../url/clean-url");
+var _encode = require("../url/encode");
+var _console = require("../util/console");
+var _stringify = require("../util/stringify");
+var _submitData = require("../util/submit-data");
+class Harvester {
+  #started = false;
+  initializedAggregates = [];
+  constructor(agentRef) {
+    this.agentRef = agentRef;
+    (0, _eol.subscribeToEOL)(() => {
+      // do one last harvest round or check
+      this.initializedAggregates.forEach(aggregateInst => {
+        // let all features wrap up things needed to do before ANY harvest in case there's last minute cross-feature data dependencies
+        if (typeof aggregateInst.harvestOpts.beforeUnload === 'function') aggregateInst.harvestOpts.beforeUnload();
+      });
+      this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst, {
+        isFinalHarvest: true
+      }));
+      /* This callback should run in bubble phase, so that that CWV api, like "onLCP", is called before the final harvest so that emitted timings are part of last outgoing. */
+    }, false);
+
+    /* 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. */
+    agentRef.ee.on(_constants.SESSION_EVENTS.RESET, () => this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst, {
+      forceNoRetry: true
+    })));
+  }
+  startTimer(harvestInterval = this.agentRef.init.harvest.interval) {
+    if (this.#started) return;
+    this.#started = true;
+    const onHarvestInterval = () => {
+      this.initializedAggregates.forEach(aggregateInst => this.triggerHarvestFor(aggregateInst));
+      setTimeout(onHarvestInterval, harvestInterval * 1000); // repeat in X seconds
+    };
+    setTimeout(onHarvestInterval, harvestInterval * 1000);
+  }
+
+  /**
+   * Given a feature (aggregate), execute a harvest on-demand.
+   * @param {object} aggregateInst
+   * @param {object} localOpts
+   * @returns {boolean} True if 1+ network call was made. Note that this does not mean or guarantee that it was successful (or that all were in the case of more than 1).
+   */
+  triggerHarvestFor(aggregateInst, localOpts = {}) {
+    if (aggregateInst.blocked) return false;
+    const submitMethod = (0, _submitData.getSubmitMethod)(localOpts);
+    if (!submitMethod) return false;
+    const shouldRetryOnFail = !localOpts.isFinalHarvest && submitMethod === _submitData.xhr; // always retry all features harvests except for final
+    let dataToSendArr;
+    let ranSend = false;
+    if (!localOpts.directSend) {
+      // primarily used by rum call to bypass makeHarvestPayload by providing payload directly
+      dataToSendArr = aggregateInst.makeHarvestPayload(shouldRetryOnFail); // be sure the 'this' of makeHarvestPayload is the aggregate w/ access to its harvestOpts
+      if (!dataToSendArr) return false; // can be undefined if storage is empty or preharvest checks failed
+    } else dataToSendArr = [localOpts.directSend];
+    dataToSendArr.forEach(({
+      targetApp,
+      payload
+    }) => {
+      if (!payload) return;
+      send(this.agentRef, {
+        endpoint: _features.FEATURE_TO_ENDPOINT[aggregateInst.featureName],
+        targetApp,
+        payload,
+        localOpts,
+        submitMethod,
+        cbFinished,
+        raw: aggregateInst.harvestOpts.raw
+      });
+      ranSend = true;
+    });
+    return ranSend;
+
+    /**
+     * 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 - information regarding the result of the harvest attempt
+     */
+    function cbFinished(result) {
+      if (localOpts.forceNoRetry) result.retry = false; // discard unsent data rather than re-queuing for next harvest attempt
+      aggregateInst.postHarvestCleanup(result);
+    }
+  }
+}
+
+/**
+ * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
+ */
+exports.Harvester = Harvester;
+const warnings = {};
+/**
+  * Initiate a harvest call.
+  * @param {NetworkSendSpec} param0 Specification for sending data
+  * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
+  */
+function send(agentRef, {
+  endpoint,
+  targetApp,
+  payload,
+  localOpts = {},
+  submitMethod,
+  cbFinished,
+  raw
+}) {
+  if (!agentRef.info.errorBeacon) return false;
+  let {
+    body,
+    qs
+  } = cleanPayload(payload);
+  if (Object.keys(body).length === 0 && !localOpts.sendEmptyBody) {
+    // if there's no body to send, just run onfinish stuff and return
+    if (cbFinished) cbFinished({
+      sent: false,
+      targetApp
+    });
+    return false;
+  }
+  const protocol = agentRef.init.ssl === false ? 'http' : 'https';
+  const perceivedBeacon = agentRef.init.proxy.beacon || agentRef.info.errorBeacon;
+  const url = raw ? "".concat(protocol, "://").concat(perceivedBeacon, "/").concat(endpoint) : "".concat(protocol, "://").concat(perceivedBeacon).concat(endpoint !== _features.RUM ? '/' + endpoint : '', "/1/").concat(targetApp.licenseKey);
+  const baseParams = !raw ? baseQueryString(agentRef, qs, endpoint, targetApp.appId) : '';
+  let payloadParams = (0, _encode.obj)(qs, agentRef.runtime.maxBytes);
+  if (baseParams === '' && payloadParams.startsWith('&')) {
+    payloadParams = payloadParams.substring(1);
+  }
+  const fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
+  const gzip = !!qs?.attributes?.includes('gzip');
+  if (!gzip) {
+    if (endpoint !== _features.EVENTS) body = (0, _stringify.stringify)(body); // all features going to 'events' endpoint should already be serialized & stringified
+    // Warn--once per endpoint--if the agent tries to send large payloads
+    if (body.length > 750000 && (warnings[endpoint] = (warnings[endpoint] || 0) + 1) === 1) (0, _console.warn)(28, endpoint);
+  }
+
+  // If body is null, undefined, or an empty object or array after stringifying, send an empty string instead.
+  if (!body || body.length === 0 || body === '{}' || body === '[]') body = '';
+  const headers = [{
+    key: 'content-type',
+    value: 'text/plain'
+  }];
+
+  /* Since workers don't support sendBeacon right now, they can only use XHR method.
+      Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
+      we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon.
+     Following the removal of img-element method. */
+  let result = submitMethod({
+    url: fullUrl,
+    body,
+    sync: localOpts.isFinalHarvest && _runtime.isWorkerScope,
+    headers
+  });
+  if (!localOpts.isFinalHarvest && cbFinished) {
+    // final harvests don't hold onto buffer data (shouldRetryOnFail is false), so cleanup isn't needed
+    if (submitMethod === _submitData.xhr) {
+      result.addEventListener('loadend', function () {
+        // `this` here in block refers to the XHR object in this scope, do not change the anon function to an arrow function
+        // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
+        const cbResult = {
+          sent: this.status !== 0,
+          status: this.status,
+          retry: shouldRetry(this.status),
+          xhr: this,
+          fullUrl,
+          targetApp
+        };
+        if (localOpts.needResponse) cbResult.responseText = this.responseText;
+        cbFinished(cbResult);
+      }, (0, _eventListenerOpts.eventListenerOpts)(false));
+    } else if (submitMethod === _submitData.xhrFetch) {
+      result.then(async function (response) {
+        const status = response.status;
+        const cbResult = {
+          sent: true,
+          status,
+          retry: shouldRetry(status),
+          fullUrl,
+          fetchResponse: response,
+          targetApp
+        };
+        if (localOpts.needResponse) cbResult.responseText = await response.text();
+        cbFinished(cbResult);
+      });
+    }
+  }
+  return true;
+  function shouldRetry(status) {
+    switch (status) {
+      case 429:
+      case 408:
+      case 500:
+      case 503:
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+
+/**
+ * Cleans and returns a payload object containing a body and qs
+ * object with key/value pairs. KV pairs where the value is null,
+ * undefined, or an empty string are removed to save on transmission
+ * size.
+ * @param {HarvestPayload} payload Payload to be sent to the endpoint.
+ * @returns {HarvestPayload} Cleaned payload payload to be sent to the endpoint.
+ */
+function cleanPayload(payload = {}) {
+  const clean = input => {
+    if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array || Array.isArray(input)) return input;
+    if (typeof input === 'string') return input.length > 0 ? input : null;
+    return Object.entries(input || {}).reduce((accumulator, [key, value]) => {
+      if (typeof value === 'number' || typeof value === 'string' && value.length > 0 || typeof value === 'object' && Object.keys(value || {}).length > 0) {
+        accumulator[key] = value;
+      }
+      return accumulator;
+    }, {});
+  };
+  return {
+    body: clean(payload.body),
+    qs: clean(payload.qs)
+  };
+}
+
+// The stuff that gets sent every time.
+function baseQueryString(agentRef, qs, endpoint, applicationID) {
+  const ref = agentRef.runtime.obfuscator.obfuscateString((0, _cleanUrl.cleanURL)('' + _runtime.globalScope.location));
+  const hr = agentRef.runtime.session?.state.sessionReplayMode === 1 && endpoint !== _features.JSERRORS;
+  const qps = ['a=' + applicationID, (0, _encode.param)('sa', agentRef.info.sa ? '' + agentRef.info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(), (0, _encode.param)('ct', agentRef.runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
+  // ck param DEPRECATED - still expected by backend
+  '&s=' + (agentRef.runtime.session?.state.value || '0'),
+  // the 0 id encaps all untrackable and default traffic
+  (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', agentRef.runtime.ptid ? '' + agentRef.runtime.ptid : '')];
+  if (hr) qps.push((0, _encode.param)('hr', '1', qs));
+  return qps.join('');
+
+  // Constructs the transaction name param for the beacon URL.
+  // Prefers the obfuscated transaction name over the plain text.
+  // Falls back to making up a name.
+  function transactionNameParam() {
+    if (agentRef.info.transactionName) return (0, _encode.param)('to', agentRef.info.transactionName);
+    return (0, _encode.param)('t', agentRef.info.tNamePlain || 'Unnamed Transaction');
+  }
+}

package/dist/cjs/common/harvest/types.js

@@ -20,32 +20,16 @@ exports.unused = void 0;
  * @property {object} body Map of values that should be sent as the body of the request.
  */
 
-/**
- * @typedef {object} FeatureHarvestCallbackOptions Options for aggregating data for harvesting.
- * @property {boolean} options.retry Indicates if the feature should store the aggregated
- * data in anticipation of a possible need to retry the transmission.
- */
-
-/**
- * @callback FeatureHarvestCallback
- * @param {FeatureHarvestCallbackOptions} options Options for aggregating data for harvesting.
- * @returns {HarvestPayload} Payload of data to transmit to bam endpoint.
- */
-
 /**
  * @typedef {object} NetworkSendSpec
  * @property {HarvestEndpointIdentifier} endpoint The endpoint to use (jserrors, events, resources etc.)
  * @property {HarvestPayload} payload Object representing payload.
- * @property {object} opts Additional options for sending data
- * @property {boolean} opts.needResponse Specify whether the caller expects a response data.
- * @property {boolean} opts.unload Specify whether the call is a final harvest during page unload.
- * @property {boolean} opts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
- * @property {boolean} opts.retry Indicates if the feature should store the aggregated data in anticipation of a possible need to
- * retry the transmission.
+ * @property {object} localOpts Additional options for sending data
+ * @property {boolean} localOpts.needResponse Specify whether the caller expects a response data.
+ * @property {boolean} localOpts.isFinalHarvest Specify whether the call is a final harvest during page unload.
+ * @property {boolean} localOpts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
+ * @property {boolean} localOpts.forceNoRetry Don't save the buffered data in the case of a need to retry the transmission.
  * @property {import('../util/submit-data.js').NetworkMethods} submitMethod The network method to use {@link ../util/submit-data.js}
- * @property {string} customUrl Override the beacon url the data is sent to; must include protocol if defined
- * @property {boolean} raw If true, disables adding the license key to the url
- * @property {boolean} includeBaseParams Enables the use of base query parameters in the beacon url
  */
 
 /* istanbul ignore next */

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

@@ -7,7 +7,6 @@ exports.Aggregate = void 0;
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _stringify = require("../../../common/util/stringify");
 var _handle = require("../../../common/event-emitter/handle");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _denyList = require("../../../common/deny-list/deny-list");
 var _constants = require("../constants");
 var _features = require("../../../loaders/features/features");
@@ -24,7 +23,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
-    const harvestTimeSeconds = agentRef.init.ajax.harvestTimeSeconds || 10;
     (0, _denyList.setDenyList)(agentRef.runtime.denyList);
     this.underSpaEvents = {};
     const classThis = this;
@@ -46,14 +44,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       // the EE-drain system not only switches "this" but also passes a new EventContext with info. Should consider platform refactor to another system which passes a mutable context around separately and predictably to avoid problems like this.
       classThis.storeXhr(...arguments, this); // this switches the context back to the class instance while passing the NR context as an argument -- see "ctx" in storeXhr
     }, this.featureName, this.ee);
-    this.waitForFlags([]).then(() => {
-      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();
-    });
+    this.waitForFlags([]).then(() => this.drain());
   }
   storeXhr(params, metrics, startTime, endTime, type, ctx) {
     metrics.time = startTime;
@@ -71,7 +62,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     // Report ajax timeslice metric (to be harvested by jserrors feature, but only if it's running).
     if (jserrorsInUse && (shouldCollect || !shouldOmitAjaxMetrics)) {
-      this.agentRef.sharedAggregator.add('xhr', hash, params, metrics);
+      this.agentRef.sharedAggregator.add(['xhr', hash, params, metrics]);
     }
     if (!shouldCollect) {
       if (params.hostname === this.agentRef.info.errorBeacon || this.agentRef.init.proxy?.beacon && params.hostname === this.agentRef.init.proxy.beacon) {

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Aggregate = void 0;
 var _stringify = require("../../../common/util/stringify");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _cleanUrl = require("../../../common/url/clean-url");
 var _constants = require("../constants");
 var _runtime = require("../../../common/constants/runtime");
@@ -15,7 +14,6 @@ var _now = require("../../../common/timing/now");
 var _registerHandler = require("../../../common/event-emitter/register-handler");
 var _constants2 = require("../../metrics/constants");
 var _traverse = require("../../../common/util/traverse");
-var _features = require("../../../loaders/features/features");
 var _userActionsAggregator = require("./user-actions/user-actions-aggregator");
 var _iframe = require("../../../common/dom/iframe");
 var _handle = require("../../../common/event-emitter/handle");
@@ -29,7 +27,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
     this.eventsPerHarvest = 1000;
-    this.harvestTimeSeconds = agentRef.init.generic_events.harvestTimeSeconds;
     this.referrerUrl = _runtime.isBrowserScope && document.referrer ? (0, _cleanUrl.cleanURL)(document.referrer) : undefined;
     this.waitForFlags(['ins']).then(([ins]) => {
       if (!ins) {
@@ -65,6 +62,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       let addUserAction;
       if (_runtime.isBrowserScope && agentRef.init.user_actions.enabled) {
         this.userActionAggregator = new _userActionsAggregator.UserActionsAggregator();
+        this.harvestOpts.beforeUnload = () => addUserAction?.(this.userActionAggregator.aggregationEvent);
         addUserAction = aggregatedUserAction => {
           try {
             /** The aggregator process only returns an event when it is "done" aggregating -
@@ -200,12 +198,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           }
         }, this.featureName, this.ee);
       }
-      this.harvestScheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
-        onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
-        onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
-      }, this);
-      this.harvestScheduler.harvest.on(_features.FEATURE_TO_ENDPOINT[this.featureName], options => this.makeHarvestPayload(options.retry));
-      this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0);
+      agentRef.runtime.harvester.triggerHarvestFor(this);
       this.drain();
     });
   }
@@ -255,7 +248,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
        * if it fails again, we do nothing
        */
       this.ee.emit(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen']);
-      this.harvestScheduler.runHarvest();
+      this.agentRef.runtime.harvester.triggerHarvestFor(this);
       this.events.add(eventAttributes);
     }
   }

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

@@ -9,7 +9,6 @@ var _computeStackTrace = require("./compute-stack-trace");
 var _stringHashCode = require("./string-hash-code");
 var _formatStackTrace = require("./format-stack-trace");
 var _registerHandler = require("../../../common/event-emitter/register-handler");
-var _harvestScheduler = require("../../../common/harvest/harvest-scheduler");
 var _stringify = require("../../../common/util/stringify");
 var _handle = require("../../../common/event-emitter/handle");
 var _runtime = require("../../../common/constants/runtime");
@@ -45,21 +44,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
 
-    const harvestTimeSeconds = agentRef.init.jserrors.harvestTimeSeconds || 10;
-    const aggregatorTypes = ['err', 'ierr', 'xhr']; // the types in EventAggregator this feature cares about
+    this.harvestOpts.aggregatorTypes = ['err', 'ierr', 'xhr']; // the types in EventAggregator this feature cares about
 
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        const scheduler = new _harvestScheduler.HarvestScheduler(_features.FEATURE_TO_ENDPOINT[this.featureName], {
-          onFinished: result => this.postHarvestCleanup(result.sent && result.retry, {
-            aggregatorTypes
-          })
-        }, this);
-        scheduler.harvest.on(_features.FEATURE_TO_ENDPOINT[this.featureName], options => this.makeHarvestPayload(options.retry, {
-          aggregatorTypes
-        }));
-        scheduler.startTimer(harvestTimeSeconds);
         this.drain();
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
@@ -225,7 +214,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     const jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(allCustomAttrs));
     const aggregateHash = bucketHash + ':' + jsAttributesHash;
-    this.events.add(type, aggregateHash, params, newMetrics, allCustomAttrs);
+    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs]);
     function setCustom(key, val) {
       allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
     }
@@ -249,7 +238,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
       var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(allCustomAttrs));
       var aggregateHash = hash + ':' + jsAttributesHash;
-      this.events.add(item[0], aggregateHash, params, item[3], allCustomAttrs);
+      this.events.add([item[0], aggregateHash, params, item[3], allCustomAttrs]);
       function setCustom([key, val]) {
         allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
       }

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