@newrelic/browser-agent 1.264.0 → 1.265.1

package/dist/esm/common/vitals/largest-contentful-paint.js

@@ -5,11 +5,10 @@ import { initiallyHidden, isBrowserScope } from '../constants/runtime';
 import { cleanURL } from '../url/clean-url';
 export const largestContentfulPaint = new VitalMetric(VITAL_NAMES.LARGEST_CONTENTFUL_PAINT);
 if (isBrowserScope) {
-  onLCP(_ref => {
-    let {
-      value,
-      attribution
-    } = _ref;
+  onLCP(({
+    value,
+    attribution
+  }) => {
     /* Largest Contentful Paint - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
     if (initiallyHidden || largestContentfulPaint.isValid) return;
     let attrs;

package/dist/esm/common/vitals/time-to-first-byte.js

@@ -12,11 +12,10 @@ export const timeToFirstByte = new VitalMetric(VITAL_NAMES.TIME_TO_FIRST_BYTE);
  * - cross-origin iframes specifically in firefox and safari
  */
 if (isBrowserScope && typeof PerformanceNavigationTiming !== 'undefined' && !isiOS && window === window.parent) {
-  onTTFB(_ref => {
-    let {
-      value,
-      attribution
-    } = _ref;
+  onTTFB(({
+    value,
+    attribution
+  }) => {
     if (timeToFirstByte.isValid) return;
     timeToFirstByte.update({
       value,

package/dist/esm/common/vitals/vital-metric.js

@@ -1,16 +1,15 @@
 export class VitalMetric {
-  #subscribers = (() => new Set())();
+  #subscribers = new Set();
   history = [];
   constructor(name, roundingMethod) {
     this.name = name;
     this.attrs = {};
     this.roundingMethod = typeof roundingMethod === 'function' ? roundingMethod : Math.floor;
   }
-  update(_ref) {
-    let {
-      value,
-      attrs = {}
-    } = _ref;
+  update({
+    value,
+    attrs = {}
+  }) {
     if (value === undefined || value === null || value < 0) return;
     const state = {
       value: this.roundingMethod(value),
@@ -36,8 +35,7 @@ export class VitalMetric {
   get isValid() {
     return this.current.value >= 0;
   }
-  subscribe(callback) {
-    let buffered = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  subscribe(callback, buffered = true) {
     if (typeof callback !== 'function') return;
     this.#subscribers.add(callback);
     // emit full history on subscription ("buffered" behavior)

package/dist/esm/common/window/nreum.js

@@ -50,7 +50,8 @@ export function gosNREUMOriginals() {
       PR: globalScope.Promise,
       MO: globalScope.MutationObserver,
       // this'll be undefined if not in a web window
-      FETCH: globalScope.fetch
+      FETCH: globalScope.fetch,
+      WS: globalScope.WebSocket
     };
   }
   return nr;

package/dist/esm/common/window/page-visibility.js

@@ -10,10 +10,7 @@ import { documentAddEventListener } from '../event-listener/event-listener-opts'
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-export function subscribeToVisibilityChange(cb) {
-  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  let capture = arguments.length > 2 ? arguments[2] : undefined;
-  let abortSignal = arguments.length > 3 ? arguments[3] : undefined;
+export function subscribeToVisibilityChange(cb, toHiddenOnly = false, capture, abortSignal) {
   documentAddEventListener('visibilitychange', handleVisibilityChange, capture, abortSignal);
   function handleVisibilityChange() {
     if (toHiddenOnly) {

package/dist/esm/common/wrap/wrap-events.js

@@ -75,14 +75,11 @@ export function wrapEvents(sharedEE) {
  * @param {Function} cb - the function to run on the ancestral object once found, accepts an object as a arg
  * @param {Array} rest - [optional] any additional arguments to pass to the cb
  */
-function findEventListenerProtoAndCb(object, cb) {
+function findEventListenerProtoAndCb(object, cb, ...rest) {
   let step = object;
   while (typeof step === 'object' && !Object.prototype.hasOwnProperty.call(step, ADD_EVENT_LISTENER)) {
     step = Object.getPrototypeOf(step);
   }
-  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-    rest[_key - 2] = arguments[_key];
-  }
   if (step) cb(step, ...rest);
 }
 

package/dist/esm/common/wrap/wrap-promise.js

@@ -104,13 +104,10 @@ export function wrapPromise(sharedEE) {
 
     // Note that this wrapping affects the same originals.PR (prototype) object.
     const prevPromiseOrigThen = prevPromiseObj.prototype.then;
-    prevPromiseObj.prototype.then = function wrappedThen() {
+    prevPromiseObj.prototype.then = function wrappedThen(...args) {
       var originalThis = this;
       var ctx = getContext(originalThis);
       ctx.promise = originalThis;
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
       args[0] = promiseWrapper(args[0], 'cb-', ctx, null, false);
       args[1] = promiseWrapper(args[1], 'cb-', ctx, null, false);
       const origFnCallWithThis = prevPromiseOrigThen.apply(this, args);

package/dist/esm/common/wrap/wrap-websocket.js

@@ -0,0 +1,67 @@
+import { globalScope } from '../constants/runtime';
+import { now } from '../timing/now';
+import { checkState } from '../window/load';
+import { generateRandomHexString } from '../ids/unique-id';
+import { gosNREUMOriginals } from '../window/nreum';
+export const WEBSOCKET_TAG = 'websocket-';
+export const ADD_EVENT_LISTENER_TAG = 'addEventListener';
+const wrapped = {};
+export function wrapWebSocket(sharedEE) {
+  if (wrapped[sharedEE.debugId]++) return sharedEE;
+  const originals = gosNREUMOriginals().o;
+  if (!originals.WS) return sharedEE;
+  function reporter(socketId) {
+    const createdAt = now();
+    return function (message, ...data) {
+      const timestamp = data[0]?.timeStamp || now();
+      const isLoaded = checkState();
+      sharedEE.emit(WEBSOCKET_TAG + message, [timestamp, timestamp - createdAt, isLoaded, socketId, ...data]);
+    };
+  }
+  Object.defineProperty(WrappedWebSocket, 'name', {
+    value: 'WebSocket'
+  });
+  function WrappedWebSocket() {
+    const ws = new originals.WS(...arguments);
+    const socketId = generateRandomHexString(6);
+    const report = reporter(socketId);
+    report('new');
+    const events = ['message', 'error', 'open', 'close'];
+    /** add event listeners */
+    events.forEach(evt => {
+      ws.addEventListener(evt, function (e) {
+        report(ADD_EVENT_LISTENER_TAG, {
+          eventType: evt,
+          event: e
+        });
+      });
+    })
+
+    /** could also observe the on-events for runtime processing, but not implemented yet */
+
+    /** observe the static method send, but noteably not close, as that is currently observed with the event listener */;
+    ['send'].forEach(wrapStaticProperty);
+    function wrapStaticProperty(prop) {
+      const originalProp = ws[prop];
+      if (originalProp) {
+        Object.defineProperty(proxiedProp, 'name', {
+          value: prop
+        });
+        function proxiedProp() {
+          report(prop, ...arguments);
+          try {
+            return originalProp.apply(this, arguments);
+          } catch (err) {
+            report(prop + '-err', ...arguments);
+            // rethrow error so we don't effect execution by observing.
+            throw err;
+          }
+        }
+        ws[prop] = proxiedProp;
+      }
+    }
+    return ws;
+  }
+  globalScope.WebSocket = WrappedWebSocket;
+  return sharedEE;
+}

package/dist/esm/features/ajax/aggregate/chunk.js

@@ -1,5 +1,6 @@
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
-import { getInfo } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 export default class Chunk {
   constructor(events, aggregateInstance) {
     this.addString = getAddStringContext(aggregateInstance.agentIdentifier); // pass agentIdentifier here
@@ -38,6 +39,6 @@ export default class Chunk {
       if (i + 1 < events.length) insert += ';';
       this.payload += insert;
     }
-    this.tooBig = this.payload.length * 2 > aggregateInstance.MAX_PAYLOAD_SIZE;
+    this.tooBig = this.payload.length * 2 > MAX_PAYLOAD_SIZE;
   }
 }

package/dist/esm/features/ajax/aggregate/gql.js

@@ -14,11 +14,10 @@ import { isPureObject } from '../../../common/util/type-check';
  * @param {string} query Ajax request query param string
  * @returns {GQLMetadata | undefined}
  */
-export function parseGQL() {
-  let {
-    body,
-    query
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+export function parseGQL({
+  body,
+  query
+} = {}) {
   if (!body && !query) return;
   try {
     const gqlBody = parseBatchGQL(parseGQLContents(body));

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

@@ -5,7 +5,9 @@
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { stringify } from '../../../common/util/stringify';
 import { handle } from '../../../common/event-emitter/handle';
-import { getConfiguration, getInfo, getRuntime } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getConfiguration } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list';
 import { FEATURE_NAME } from '../constants';
@@ -15,8 +17,9 @@ import { AggregateBase } from '../../utils/aggregate-base';
 import { parseGQL } from './gql';
 import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 import Chunk from './chunk';
+import { EventBuffer } from '../../utils/event-buffer';
 export class Aggregate extends AggregateBase {
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   #agentInfo;
   #agentRuntime;
   #agentInit;
@@ -26,25 +29,23 @@ export class Aggregate extends AggregateBase {
     this.#agentRuntime = getRuntime(agentIdentifier);
     this.#agentInit = getConfiguration(agentIdentifier);
     const harvestTimeSeconds = this.#agentInit.ajax.harvestTimeSeconds || 10;
-    this.MAX_PAYLOAD_SIZE = this.#agentInit.ajax.maxPayloadSize || 1000000;
     setDenyList(this.#agentRuntime.denyList);
-    this.ajaxEvents = [];
+    this.ajaxEvents = new EventBuffer();
     this.spaAjaxEvents = {};
-    this.sentAjaxEvents = [];
     const classThis = this;
 
     // --- v Used by old spa feature
     this.ee.on('interactionDone', (interaction, wasSaved) => {
-      if (!this.spaAjaxEvents[interaction.id]) return;
+      if (!this.spaAjaxEvents[interaction.id]?.hasData) return;
       if (!wasSaved) {
         // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
-        this.spaAjaxEvents[interaction.id].forEach(item => this.ajaxEvents.push(item));
+        this.ajaxEvents.merge(this.spaAjaxEvents[interaction.id]);
       }
       delete this.spaAjaxEvents[interaction.id];
     });
     // --- ^
     // --- v Used by new soft nav
-    registerHandler('returnAjax', event => this.ajaxEvents.push(event), this.featureName, this.ee);
+    registerHandler('returnAjax', event => this.ajaxEvents.add(event), this.featureName, this.ee);
     // --- ^
     registerHandler('xhr', function () {
       // 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.
@@ -104,7 +105,7 @@ export class Aggregate extends AggregateBase {
     if (ctx.dt) {
       event.spanId = ctx.dt.spanId;
       event.traceId = ctx.dt.traceId;
-      event.spanTimestamp = this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp);
+      event.spanTimestamp = Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(ctx.dt.timestamp));
     }
 
     // parsed from the AJAX body, looking for operationName param & parsing query for operationType
@@ -120,31 +121,27 @@ export class Aggregate extends AggregateBase {
     } else if (ctx.spaNode) {
       // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
       const interactionId = ctx.spaNode.interaction.id;
-      this.spaAjaxEvents[interactionId] = this.spaAjaxEvents[interactionId] || [];
-      this.spaAjaxEvents[interactionId].push(event);
+      this.spaAjaxEvents[interactionId] ??= new EventBuffer();
+      this.spaAjaxEvents[interactionId].add(event);
     } else {
-      this.ajaxEvents.push(event);
+      this.ajaxEvents.add(event);
     }
   }
   prepareHarvest(options) {
     options = options || {};
-    if (this.ajaxEvents.length === 0) return null;
-    const payload = this.#getPayload(this.ajaxEvents);
+    if (this.ajaxEvents.buffer.length === 0) return null;
+    const payload = this.#getPayload(this.ajaxEvents.buffer);
     const payloadObjs = [];
     for (let i = 0; i < payload.length; i++) payloadObjs.push({
       body: {
         e: payload[i]
       }
     });
-    if (options.retry) this.sentAjaxEvents = this.ajaxEvents;
-    this.ajaxEvents = [];
+    if (options.retry) this.ajaxEvents.hold();else this.ajaxEvents.clear();
     return payloadObjs;
   }
   onEventsHarvestFinished(result) {
-    if (result.retry && this.sentAjaxEvents.length > 0) {
-      this.ajaxEvents.unshift(...this.sentAjaxEvents);
-      this.sentAjaxEvents = [];
-    }
+    if (result.retry && this.ajaxEvents.held.hasData) this.ajaxEvents.unhold();else this.ajaxEvents.held.clear();
   }
   #getPayload(events, numberOfChunks) {
     numberOfChunks = numberOfChunks || 1;

package/dist/esm/features/ajax/constants.js

@@ -1,3 +1,2 @@
 import { FEATURE_NAMES } from '../../loaders/features/features';
-export const FEATURE_NAME = FEATURE_NAMES.ajax;
-export const MAX_PAYLOAD_SIZE = 1000000;
+export const FEATURE_NAME = FEATURE_NAMES.ajax;

package/dist/esm/features/ajax/instrument/distributed-tracing.js

@@ -2,7 +2,8 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getConfiguration, getConfigurationValue, getLoaderConfig } from '../../../common/config/config';
+import { getConfiguration, getConfigurationValue } from '../../../common/config/init';
+import { getLoaderConfig } from '../../../common/config/loader-config';
 import { generateSpanId, generateTraceId } from '../../../common/ids/unique-id';
 import { parseUrl } from '../../../common/url/parse-url';
 import { globalScope } from '../../../common/constants/runtime';

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

@@ -2,13 +2,15 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { originals, getLoaderConfig } from '../../../common/config/config';
+import { gosNREUMOriginals } from '../../../common/window/nreum';
+import { getLoaderConfig } from '../../../common/config/loader-config';
 import { handle } from '../../../common/event-emitter/handle';
 import { id } from '../../../common/ids/id';
 import { ffVersion, globalScope, isBrowserScope } from '../../../common/constants/runtime';
 import { dataSize } from '../../../common/util/data-size';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
-import { wrapFetch, wrapXhr } from '../../../common/wrap';
+import { wrapXhr } from '../../../common/wrap/wrap-xhr';
+import { wrapFetch } from '../../../common/wrap/wrap-fetch';
 import { parseUrl } from '../../../common/url/parse-url';
 import { DT } from './distributed-tracing';
 import { responseSizeFromXhr } from './response-size';
@@ -20,12 +22,11 @@ import { now } from '../../../common/timing/now';
 import { hasUndefinedHostname } from '../../../common/deny-list/deny-list';
 var handlers = ['load', 'error', 'abort', 'timeout'];
 var handlersLen = handlers.length;
-var origRequest = originals.REQ;
-var origXHR = originals.XHR;
+var origRequest = gosNREUMOriginals().o.REQ;
+var origXHR = gosNREUMOriginals().o.XHR;
 export class Instrument extends InstrumentBase {
-  static featureName = (() => FEATURE_NAME)();
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     this.dt = new DT(agentIdentifier);
     this.handler = (type, args, ctx, group) => handle(type, args, ctx, group, this.ee);
@@ -339,7 +340,7 @@ function subscribeToEvents(agentIdentifier, ee, handler, dt) {
     if (hasUndefinedHostname(params)) return; // don't bother with XHR of url with no hostname
 
     metrics.duration = now() - this.startTime;
-    if (!this.loadCaptureCalled && xhr.readyState === 4) {
+    if (!this.loadCazptureCalled && xhr.readyState === 4) {
       captureXhrData(this, xhr);
     } else if (params.status == null) {
       params.status = 0;
@@ -373,4 +374,5 @@ function addUrl(ctx, url) {
   params.pathname = parsed.pathname;
   ctx.parsedOrigin = parsed;
   ctx.sameOrigin = parsed.sameOrigin;
-}
+}
+export const Ajax = Instrument;

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

@@ -5,7 +5,9 @@
 import { stringify } from '../../../common/util/stringify';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { cleanURL } from '../../../common/url/clean-url';
-import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
+import { getInfo } from '../../../common/config/info';
+import { getConfigurationValue } from '../../../common/config/init';
+import { getRuntime } from '../../../common/config/runtime';
 import { FEATURE_NAME } from '../constants';
 import { isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
@@ -14,22 +16,20 @@ import { now } from '../../../common/timing/now';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 import { deregisterDrain } from '../../../common/drain/drain';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
+import { EventBuffer } from '../../utils/event-buffer';
+import { applyFnToProps } from '../../../common/util/traverse';
+import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 export class Aggregate extends AggregateBase {
   #agentRuntime;
-  static featureName = (() => FEATURE_NAME)();
+  static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
-    var _this;
     super(agentIdentifier, aggregator, FEATURE_NAME);
-    _this = this;
     this.eventsPerHarvest = 1000;
     this.harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'generic_events.harvestTimeSeconds');
     this.referrerUrl = isBrowserScope && document.referrer ? cleanURL(document.referrer) : undefined;
-    this.currentEvents = [];
-    this.events = [];
-    this.overflow = [];
+    this.events = new EventBuffer();
     this.#agentRuntime = getRuntime(this.agentIdentifier);
-    this.waitForFlags(['ins']).then(_ref => {
-      let [ins] = _ref;
+    this.waitForFlags(['ins']).then(([ins]) => {
       if (!ins) {
         this.blocked = true;
         deregisterDrain(this.agentIdentifier, this.featureName);
@@ -40,7 +40,7 @@ export class Aggregate extends AggregateBase {
           this.addEvent({
             ...attributes,
             eventType: 'PageAction',
-            timestamp: this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp),
+            timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp))),
             timeSinceLoad: timestamp / 1000,
             actionName: name,
             referrerUrl: this.referrerUrl,
@@ -53,47 +53,16 @@ export class Aggregate extends AggregateBase {
         }, this.featureName, this.ee);
       }
       this.harvestScheduler = new HarvestScheduler('ins', {
-        onFinished: function () {
-          return _this.onHarvestFinished(...arguments);
-        }
+        onFinished: (...args) => this.onHarvestFinished(...args)
       }, this);
-      this.harvestScheduler.harvest.on('ins', function () {
-        return _this.onHarvestStarted(...arguments);
-      });
+      this.harvestScheduler.harvest.on('ins', (...args) => this.onHarvestStarted(...args));
       this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0);
       this.drain();
     });
   }
-  onHarvestStarted(options) {
-    const {
-      userAttributes,
-      atts
-    } = getInfo(this.agentIdentifier);
-    const harvestEvents = this.overflow.length ? this.overflow.splice(0, Infinity) : this.events.splice(0, Infinity);
-    var payload = {
-      qs: {
-        ua: userAttributes,
-        at: atts
-      },
-      body: {
-        ins: harvestEvents
-      }
-    };
-    if (options.retry) {
-      this.currentEvents = harvestEvents;
-    }
-    return payload;
-  }
-  onHarvestFinished(result) {
-    if (result && result.sent && result.retry && this.currentEvents.length) {
-      this.events = this.currentEvents.concat(this.events);
-      this.currentEvents = [];
-    }
-  }
 
   // WARNING: Insights times are in seconds. EXCEPT timestamp, which is in ms.
-  addEvent() {
-    let obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  addEvent(obj = {}) {
     if (!obj || !Object.keys(obj).length) return;
     if (!obj.eventType) {
       warn(44);
@@ -105,7 +74,7 @@ export class Aggregate extends AggregateBase {
     }
     const defaultEventAttributes = {
       /** should be overridden by the event-specific attributes, but just in case -- set it to now() */
-      timestamp: this.#agentRuntime.timeKeeper.convertRelativeTimestamp(now()),
+      timestamp: Math.floor(this.#agentRuntime.timeKeeper.correctAbsoluteTimestamp(this.#agentRuntime.timeKeeper.convertRelativeTimestamp(now()))),
       /** all generic events require a pageUrl */
       pageUrl: cleanURL(getRuntime(this.agentIdentifier).origin)
     };
@@ -117,12 +86,34 @@ export class Aggregate extends AggregateBase {
       /** Event-specific attributes take precedence over agent-level custom attributes and fallbacks */
       ...obj
     };
-    this.events.push(eventAttributes);
-
-    // check if we've reached the harvest limit...
-    if (this.events.length >= this.eventsPerHarvest) {
+    this.events.add(eventAttributes);
+    this.checkEventLimits();
+  }
+  onHarvestStarted(options) {
+    const {
+      userAttributes,
+      atts
+    } = getInfo(this.agentIdentifier);
+    if (!this.events.hasData) return;
+    var payload = {
+      qs: {
+        ua: userAttributes,
+        at: atts
+      },
+      body: applyFnToProps({
+        ins: this.events.buffer
+      }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+    };
+    if (options.retry) this.events.hold();
+    return payload;
+  }
+  onHarvestFinished(result) {
+    if (result && result?.sent && result?.retry && this.events.held.hasData) this.events.unhold();else this.events.held.clear();
+  }
+  checkEventLimits() {
+    // check if we've reached any harvest limits...
+    if (this.events.bytes > IDEAL_PAYLOAD_SIZE) {
       this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen']);
-      this.overflow = [...this.overflow, ...this.events.splice(0, Infinity)];
       this.harvestScheduler.runHarvest();
     }
   }

package/dist/esm/features/generic_events/constants.js

@@ -1,2 +1,4 @@
 import { FEATURE_NAMES } from '../../loaders/features/features';
-export const FEATURE_NAME = FEATURE_NAMES.genericEvents;
+export const FEATURE_NAME = FEATURE_NAMES.genericEvents;
+export const IDEAL_PAYLOAD_SIZE = 64000;
+export const MAX_PAYLOAD_SIZE = 1000000;

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

@@ -2,14 +2,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { getConfigurationValue } from '../../../common/config/config';
+import { getConfigurationValue } from '../../../common/config/init';
 import { deregisterDrain } from '../../../common/drain/drain';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { FEATURE_NAME } from '../constants';
 export class Instrument extends InstrumentBase {
-  static featureName = (() => FEATURE_NAME)();
-  constructor(agentIdentifier, aggregator) {
-    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  static featureName = FEATURE_NAME;
+  constructor(agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     const genericEventSourceConfigs = [getConfigurationValue(this.agentIdentifier, 'page_action.enabled')
     // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
@@ -17,4 +16,5 @@ export class Instrument extends InstrumentBase {
     /** If any of the sources are active, import the aggregator. otherwise deregister */
     if (genericEventSourceConfigs.some(x => x)) this.importAggregator();else deregisterDrain(this.agentIdentifier, this.featureName);
   }
-}
+}
+export const GenericEvents = Instrument;