@newrelic/browser-agent 1.271.0 → 1.273.0

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

@@ -12,9 +12,9 @@ import { warn } from '../../../common/util/console';
 import { now } from '../../../common/timing/now';
 import { registerHandler } from '../../../common/event-emitter/register-handler';
 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';
+import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 import { UserActionsAggregator } from './user-actions/user-actions-aggregator';
 import { isIFrameWindow } from '../../../common/dom/iframe';
 export class Aggregate extends AggregateBase {
@@ -24,14 +24,12 @@ export class Aggregate extends AggregateBase {
     this.eventsPerHarvest = 1000;
     this.harvestTimeSeconds = agentRef.init.generic_events.harvestTimeSeconds;
     this.referrerUrl = isBrowserScope && document.referrer ? cleanURL(document.referrer) : undefined;
-    this.events = new EventBuffer();
     this.waitForFlags(['ins']).then(([ins]) => {
       if (!ins) {
         this.blocked = true;
         this.deregisterDrain();
         return;
       }
-      const preHarvestMethods = [];
       if (agentRef.init.page_action.enabled) {
         registerHandler('api-addPageAction', (timestamp, name, attributes) => {
           this.addEvent({
@@ -48,9 +46,10 @@ export class Aggregate extends AggregateBase {
           });
         }, this.featureName, this.ee);
       }
+      let addUserAction;
       if (isBrowserScope && agentRef.init.user_actions.enabled) {
         this.userActionAggregator = new UserActionsAggregator();
-        this.addUserAction = aggregatedUserAction => {
+        addUserAction = aggregatedUserAction => {
           try {
             /** The aggregator process only returns an event when it is "done" aggregating -
              * so we still need to validate that an event was given to this method before we try to add */
@@ -92,21 +91,53 @@ export class Aggregate extends AggregateBase {
         };
         registerHandler('ua', evt => {
           /** the processor will return the previously aggregated event if it has been completed by processing the current event */
-          this.addUserAction(this.userActionAggregator.process(evt));
+          addUserAction(this.userActionAggregator.process(evt));
         }, this.featureName, this.ee);
-        preHarvestMethods.push((options = {}) => {
-          /** send whatever UserActions have been aggregated up to this point
-           * if we are in a final harvest. By accessing the aggregationEvent, the aggregation is then force-cleared */
-          if (options.isFinalHarvest) this.addUserAction(this.userActionAggregator.aggregationEvent);
-        });
       }
-      this.harvestScheduler = new HarvestScheduler('ins', {
-        onFinished: (...args) => this.onHarvestFinished(...args)
+
+      /**
+       * is it worth complicating the agent and skipping the POs for single repeating queries? maybe,
+       * but right now it was less desirable simply because it is a nice benefit of populating the event buffer
+       * immediately as events happen for payload evaluation purposes and that becomes a little more chaotic
+       * with an arbitrary query method. note: eventTypes: [...types] does not support the 'buffered' flag so we have
+       * to create up to two PO's here.
+       */
+      const performanceTypesToCapture = [...(agentRef.init.performance.capture_marks ? ['mark'] : []), ...(agentRef.init.performance.capture_measures ? ['measure'] : [])];
+      if (performanceTypesToCapture.length) {
+        try {
+          performanceTypesToCapture.forEach(type => {
+            if (PerformanceObserver.supportedEntryTypes.includes(type)) {
+              const observer = new PerformanceObserver(list => {
+                list.getEntries().forEach(entry => {
+                  try {
+                    this.addEvent({
+                      eventType: 'BrowserPerformance',
+                      timestamp: Math.floor(agentRef.runtime.timeKeeper.correctRelativeTimestamp(entry.startTime)),
+                      entryName: entry.name,
+                      entryDuration: entry.duration,
+                      entryType: type,
+                      ...(entry.detail && {
+                        entryDetail: entry.detail
+                      })
+                    });
+                  } catch (err) {}
+                });
+              });
+              observer.observe({
+                buffered: true,
+                type
+              });
+            }
+          });
+        } catch (err) {
+          // Something failed in our set up, likely the browser does not support PO's... do nothing
+        }
+      }
+      this.harvestScheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+        onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
+        onUnload: () => addUserAction?.(this.userActionAggregator.aggregationEvent)
       }, this);
-      this.harvestScheduler.harvest.on('ins', (...args) => {
-        preHarvestMethods.forEach(fn => fn(...args));
-        return this.onHarvestStarted(...args);
-      });
+      this.harvestScheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], options => this.makeHarvestPayload(options.retry));
       this.harvestScheduler.startTimer(this.harvestTimeSeconds, 0);
       this.drain();
     });
@@ -153,30 +184,20 @@ export class Aggregate extends AggregateBase {
     this.events.add(eventAttributes);
     this.checkEventLimits();
   }
-  onHarvestStarted(options) {
-    const {
-      userAttributes,
-      atts
-    } = this.agentRef.info;
-    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();else this.events.clear();
-    return payload;
+  serializer(eventBuffer) {
+    return applyFnToProps({
+      ins: eventBuffer
+    }, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
   }
-  onHarvestFinished(result) {
-    if (result && result?.sent && result?.retry && this.events.held.hasData) this.events.unhold();else this.events.held.clear();
+  queryStringsBuilder() {
+    return {
+      ua: this.agentRef.info.userAttributes,
+      at: this.agentRef.info.atts
+    };
   }
   checkEventLimits() {
     // check if we've reached any harvest limits...
-    if (this.events.bytes > IDEAL_PAYLOAD_SIZE) {
+    if (this.events.byteSize() > IDEAL_PAYLOAD_SIZE) {
       this.ee.emit(SUPPORTABILITY_METRIC_CHANNEL, ['GenericEvents/Harvest/Max/Seen']);
       this.harvestScheduler.runHarvest();
     }

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

@@ -11,7 +11,7 @@ export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef, auto = true) {
     super(agentRef, FEATURE_NAME, auto);
-    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.user_actions.enabled
+    const genericEventSourceConfigs = [agentRef.init.page_action.enabled, agentRef.init.performance.capture_marks, agentRef.init.performance.capture_measures, agentRef.init.user_actions.enabled
     // other future generic event source configs to go here, like M&Ms, PageResouce, etc.
     ];
     if (isBrowserScope && agentRef.init.user_actions.enabled) {

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

@@ -13,9 +13,8 @@ import { stringify } from '../../../common/util/stringify';
 import { handle } from '../../../common/event-emitter/handle';
 import { globalScope } from '../../../common/constants/runtime';
 import { FEATURE_NAME } from '../constants';
-import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
-import { getNREUMInitializedAgent } from '../../../common/window/nreum';
 import { now } from '../../../common/timing/now';
 import { applyFnToProps } from '../../../common/util/traverse';
 import { evaluateInternalError } from './internal-errors';
@@ -33,7 +32,6 @@ export class Aggregate extends AggregateBase {
     this.observedAt = {};
     this.pageviewReported = {};
     this.bufferedErrorsUnderSpa = {};
-    this.currentBody = undefined;
     this.errorOnPage = false;
 
     // this will need to change to match whatever ee we use in the instrument
@@ -43,14 +41,19 @@ export class Aggregate extends AggregateBase {
     register('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
 
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        const scheduler = new HarvestScheduler('jserrors', {
-          onFinished: (...args) => this.onHarvestFinished(...args)
+        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+          onFinished: result => this.postHarvestCleanup(result.sent && result.retry, {
+            aggregatorTypes
+          })
         }, this);
-        scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args));
+        scheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], options => this.makeHarvestPayload(options.retry, {
+          aggregatorTypes
+        }));
         scheduler.startTimer(harvestTimeSeconds);
         this.drain();
       } else {
@@ -59,49 +62,22 @@ export class Aggregate extends AggregateBase {
       }
     });
   }
-  onHarvestStarted(options) {
-    // this gets rid of dependency in AJAX module
-    var body = applyFnToProps(this.agentRef.sharedAggregator.take(['err', 'ierr', 'xhr']), this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
-    if (options.retry) {
-      this.currentBody = body;
-    }
-    var payload = {
-      body,
-      qs: {}
-    };
-    var releaseIds = stringify(this.agentRef.runtime.releaseIds);
-    if (releaseIds !== '{}') {
-      payload.qs.ri = releaseIds;
-    }
-    if (body && body.err && body.err.length) {
-      this.#runCrossFeatureChecks(body.err);
+  serializer(aggregatorTypeToBucketsMap) {
+    return applyFnToProps(aggregatorTypeToBucketsMap, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
+  }
+  queryStringsBuilder(aggregatorTakeReturnedData) {
+    const qs = {};
+    const releaseIds = stringify(this.agentRef.runtime.releaseIds);
+    if (releaseIds !== '{}') qs.ri = releaseIds;
+    if (aggregatorTakeReturnedData?.err?.length) {
       if (!this.errorOnPage) {
-        payload.qs.pve = '1';
+        qs.pve = '1';
         this.errorOnPage = true;
       }
+      // For assurance, erase any `hasReplay` flag from all errors if replay is not recording, not-yet imported, or not running at all.
+      if (!this.agentRef.features?.[FEATURE_NAMES.sessionReplay]?.featAggregate?.replayIsActive()) aggregatorTakeReturnedData.err.forEach(error => delete error.params.hasReplay);
     }
-    return payload;
-  }
-  onHarvestFinished(result) {
-    if (result.retry && this.currentBody) {
-      Object.entries(this.currentBody || {}).forEach(([key, value]) => {
-        for (var i = 0; i < value.length; i++) {
-          var bucket = value[i];
-          var name = this.getBucketName(key, bucket.params, bucket.custom);
-          this.agentRef.sharedAggregator.merge(key, name, bucket.metrics, bucket.params, bucket.custom);
-        }
-      });
-      this.currentBody = null;
-    }
-  }
-  nameHash(params) {
-    return stringHashCode("".concat(params.exceptionClass, "_").concat(params.message, "_").concat(params.stack_trace || params.browser_stack_hash));
-  }
-  getBucketName(objType, params, customParams) {
-    if (objType === 'xhr') {
-      return stringHashCode(stringify(params)) + ':' + stringHashCode(stringify(customParams));
-    }
-    return this.nameHash(params) + ':' + stringHashCode(stringify(customParams));
+    return qs;
   }
 
   /**
@@ -208,7 +184,7 @@ export class Aggregate extends AggregateBase {
       params._interactionId = err.__newrelic[this.agentIdentifier].interactionId;
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId;
     }
-    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav]);
+    const softNavInUse = Boolean(this.agentRef.features?.[FEATURE_NAMES.softNav]);
     // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
     // They each will also tack on their respective properties to the params object as part of the decision flow.
     if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee);else handle('spa-jserror', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee);
@@ -243,7 +219,7 @@ export class Aggregate extends AggregateBase {
 
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
     const aggregateHash = bucketHash + ':' + jsAttributesHash;
-    this.agentRef.sharedAggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs);
+    this.events.add(type, aggregateHash, params, newMetrics, allCustomAttrs);
     function setCustom(key, val) {
       allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
     }
@@ -267,7 +243,7 @@ export class Aggregate extends AggregateBase {
       var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
       var jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
       var aggregateHash = hash + ':' + jsAttributesHash;
-      this.agentRef.sharedAggregator.store(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' ? stringify(val) : val;
       }
@@ -280,26 +256,4 @@ export class Aggregate extends AggregateBase {
     );
     delete this.bufferedErrorsUnderSpa[interactionId]; // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
-
-  /**
-   * Dispatches a cross-feature communication event to allow other
-   * features to provide flags and data that can be used to mutation
-   * to the payload and to allow features to know about a feature
-   * harvest happening.
-   * @param {any[]} errors Array of errors from the payload body
-   */
-  #runCrossFeatureChecks(errors) {
-    const errorHashes = errors.map(error => error.params.stackHash);
-    const crossFeatureData = {
-      errorHashes
-    };
-    this.ee.emit("cfc.".concat(this.featureName), [crossFeatureData]);
-    let hasReplayFlag = errors.find(err => err.params.hasReplay);
-    if (hasReplayFlag && !crossFeatureData.hasReplay) {
-      // Some errors have `hasReplay` and a replay is not being recorded
-      errors.forEach(error => {
-        delete error.params.hasReplay;
-      });
-    }
-  }
 }

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

@@ -10,20 +10,17 @@ import { Log } from '../shared/log';
 import { isValidLogLevel } from '../shared/utils';
 import { applyFnToProps } from '../../../common/util/traverse';
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
-import { EventBuffer } from '../../utils/event-buffer';
+import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-
-    /** held logs before sending */
-    this.bufferedLogs = new EventBuffer();
     this.harvestTimeSeconds = agentRef.init.logging.harvestTimeSeconds;
     this.waitForFlags([]).then(() => {
-      this.scheduler = new HarvestScheduler('browser/logs', {
-        onFinished: this.onHarvestFinished.bind(this),
+      this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+        onFinished: result => this.postHarvestCleanup(result.sent && result.retry),
         retryDelay: this.harvestTimeSeconds,
-        getPayload: this.prepareHarvest.bind(this),
+        getPayload: options => this.makeHarvestPayload(options.retry),
         raw: true
       }, this);
       /** emitted by instrument class (wrapped loggers) or the api methods directly */
@@ -56,63 +53,59 @@ export class Aggregate extends AggregateBase {
     const log = new Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
     const logBytes = log.message.length + stringify(log.attributes).length + log.level.length + 10; // timestamp == 10 chars
 
-    if (!this.bufferedLogs.canMerge(logBytes)) {
-      if (this.bufferedLogs.hasData) {
-        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.bufferedLogs.bytes + logBytes]);
-        this.scheduler.runHarvest({});
-        if (logBytes < MAX_PAYLOAD_SIZE) this.bufferedLogs.add(log);
-      } else {
-        handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', logBytes]);
-        warn(31, log.message.slice(0, 25) + '...');
-      }
+    const failToHarvestMessage = 'Logging/Harvest/Failed/Seen';
+    if (logBytes > MAX_PAYLOAD_SIZE) {
+      // cannot possibly send this, even with an empty buffer
+      handle(SUPPORTABILITY_METRIC_CHANNEL, [failToHarvestMessage, logBytes]);
+      warn(31, log.message.slice(0, 25) + '...');
       return;
     }
-    this.bufferedLogs.add(log);
+    if (this.events.wouldExceedMaxSize(logBytes)) {
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.events.bytes + logBytes]);
+      this.scheduler.runHarvest(); // force a harvest 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
+      handle(SUPPORTABILITY_METRIC_CHANNEL, [failToHarvestMessage, logBytes]);
+      warn(31, log.message.slice(0, 25) + '...');
+    }
   }
-  prepareHarvest(options = {}) {
-    if (this.blocked || !this.bufferedLogs.hasData) return;
-    /** These attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB */
-    const unbilledAttributes = {
-      'instrumentation.provider': 'browser',
-      'instrumentation.version': this.agentRef.runtime.version,
-      'instrumentation.name': this.agentRef.runtime.loaderType
-    };
-    /** see https://source.datanerd.us/agents/rum-specs/blob/main/browser/Log for logging spec */
-    const payload = {
-      qs: {
-        browser_monitoring_key: this.agentRef.info.licenseKey
-      },
-      body: [{
-        common: {
-          /** Attributes in the `common` section are added to `all` logs generated in the payload */
-          attributes: {
-            'entity.guid': this.agentRef.runtime.appMetadata?.agents?.[0]?.entityGuid,
-            // browser entity guid as provided from RUM response
-            session: this.agentRef.runtime.session?.state.value || '0',
+  serializer(eventBuffer) {
+    const sessionEntity = this.agentRef.runtime.session;
+    return [{
+      common: {
+        /** Attributes in the `common` section are added to `all` logs generated in the payload */
+        attributes: {
+          'entity.guid': this.agentRef.runtime.appMetadata?.agents?.[0]?.entityGuid,
+          // browser entity guid as provided from RUM response
+          ...(sessionEntity && {
+            session: sessionEntity.state.value || '0',
             // The session ID that we generate and keep across page loads
-            hasReplay: this.agentRef.runtime.session?.state.sessionReplayMode === 1,
+            hasReplay: sessionEntity.state.sessionReplayMode === 1,
             // True if a session replay recording is running
-            hasTrace: this.agentRef.runtime.session?.state.sessionTraceMode === 1,
-            // True if a session trace recording is running
-            ptid: this.agentRef.runtime.ptid,
-            // page trace id
-            appId: this.agentRef.info.applicationID,
-            // Application ID from info object,
-            standalone: Boolean(this.agentRef.info.sa),
-            // copy paste (true) vs APM (false)
-            agentVersion: this.agentRef.runtime.version,
-            // browser agent version
-            ...unbilledAttributes
-          }
-        },
-        /** logs section contains individual unique log entries */
-        logs: applyFnToProps(this.bufferedLogs.buffer, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
-      }]
-    };
-    if (options.retry) this.bufferedLogs.hold();else this.bufferedLogs.clear();
-    return payload;
+            hasTrace: sessionEntity.state.sessionTraceMode === 1 // True if a session trace recording is running
+          }),
+          ptid: this.agentRef.runtime.ptid,
+          // page trace id
+          appId: this.agentRef.info.applicationID,
+          // Application ID from info object,
+          standalone: Boolean(this.agentRef.info.sa),
+          // copy paste (true) vs APM (false)
+          agentVersion: this.agentRef.runtime.version,
+          // browser agent version
+          // The following 3 attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB:
+          'instrumentation.provider': 'browser',
+          'instrumentation.version': this.agentRef.runtime.version,
+          'instrumentation.name': this.agentRef.runtime.loaderType
+        }
+      },
+      /** logs section contains individual unique log entries */
+      logs: applyFnToProps(eventBuffer, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
+    }];
   }
-  onHarvestFinished(result) {
-    if (result.retry) this.bufferedLogs.unhold();else this.bufferedLogs.held.clear();
+  queryStringsBuilder() {
+    return {
+      browser_monitoring_key: this.agentRef.info.licenseKey
+    };
   }
 }

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

@@ -7,6 +7,7 @@ import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
 import { isIFrameWindow } from '../../../common/dom/iframe';
 // import { WEBSOCKET_TAG } from '../../../common/wrap/wrap-websocket'
 // import { handleWebsocketEvents } from './websocket-detection'
@@ -15,15 +16,17 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
+    const aggregatorTypes = ['cm', 'sm']; // the types in EventAggregator this feature cares about
+
     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('jserrors', {
+        const scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
           onUnload: () => this.unload()
         }, this);
         // this is needed to ensure EoL is "on" and sent
-        scheduler.harvest.on('jserrors', () => ({
-          body: this.agentRef.sharedAggregator.take(['cm', 'sm'])
+        scheduler.harvest.on(FEATURE_TO_ENDPOINT[this.featureName], () => this.makeHarvestPayload(undefined, {
+          aggregatorTypes
         }));
         this.drain();
       } else {
@@ -44,7 +47,7 @@ export class Aggregate extends AggregateBase {
     const params = {
       name
     };
-    this.agentRef.sharedAggregator.storeMetric(type, name, params, value);
+    this.events.addMetric(type, name, params, value);
   }
   storeEventMetrics(name, metrics) {
     if (this.blocked) return;
@@ -52,7 +55,7 @@ export class Aggregate extends AggregateBase {
     const params = {
       name
     };
-    this.agentRef.sharedAggregator.store(type, name, params, metrics);
+    this.events.add(type, name, params, metrics);
   }
   singleChecks() {
     // report loaderType

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

@@ -8,7 +8,7 @@ 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 } from '../../../loaders/features/features';
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } 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';
@@ -19,7 +19,6 @@ import { largestContentfulPaint } from '../../../common/vitals/largest-contentfu
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
 import { subscribeToVisibilityChange } from '../../../common/window/page-visibility';
 import { VITAL_NAMES } from '../../../common/vitals/constants';
-import { EventBuffer } from '../../utils/event-buffer';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   #handleVitalMetric = ({
@@ -31,7 +30,6 @@ export class Aggregate extends AggregateBase {
   };
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
-    this.timings = new EventBuffer();
     this.curSessEndRecorded = false;
     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:
@@ -63,9 +61,9 @@ 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('events', {
-        onFinished: (...args) => this.onHarvestFinished(...args),
-        getPayload: (...args) => this.prepareHarvest(...args)
+      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();
@@ -98,16 +96,13 @@ export class Aggregate extends AggregateBase {
     if (name !== VITAL_NAMES.CUMULATIVE_LAYOUT_SHIFT && cumulativeLayoutShift.current.value >= 0) {
       attrs.cls = cumulativeLayoutShift.current.value;
     }
-    this.timings.add({
+    this.events.add({
       name,
       value,
       attrs
     });
     handle('pvtAdded', [name, value, attrs], undefined, FEATURE_NAMES.sessionTrace, this.ee);
   }
-  onHarvestFinished(result) {
-    if (result.retry && this.timings.held.hasData) this.timings.unhold();else this.timings.held.clear();
-  }
   appendGlobalCustomAttributes(timing) {
     var timingAttributes = timing.attrs || {};
     var reservedAttributes = ['size', 'eid', 'cls', 'type', 'fid', 'elTag', 'elUrl', 'net-type', 'net-etype', 'net-rtt', 'net-dlink'];
@@ -118,24 +113,12 @@ export class Aggregate extends AggregateBase {
     });
   }
 
-  // serialize and return current timing data, clear and save current data for retry
-  prepareHarvest(options) {
-    if (!this.timings.hasData) return;
-    var payload = this.getPayload(this.timings.buffer);
-    if (options.retry) this.timings.hold();else this.timings.clear();
-    return {
-      body: {
-        e: payload
-      }
-    };
-  }
-
   // serialize array of timing data
-  getPayload(data) {
+  serializer(eventBuffer) {
     var addString = getAddStringContext(this.agentIdentifier);
     var payload = 'bel.6;';
-    for (var i = 0; i < data.length; i++) {
-      var timing = data[i];
+    for (var i = 0; i < eventBuffer.length; i++) {
+      var timing = eventBuffer[i];
       payload += 'e,';
       payload += addString(timing.name) + ',';
       payload += nullable(timing.value, numeric, false) + ',';
@@ -144,7 +127,7 @@ export class Aggregate extends AggregateBase {
       if (attrParts && attrParts.length > 0) {
         payload += numeric(attrParts.length) + ';' + attrParts.join(';');
       }
-      if (i + 1 < data.length) payload += ';';
+      if (i + 1 < eventBuffer.length) payload += ';';
     }
     return payload;
   }

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

@@ -16,7 +16,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 } from '../../../loaders/features/features';
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } 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';
@@ -50,9 +50,6 @@ export class Aggregate extends AggregateBase {
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee);
-    this.ee.on("cfc.".concat(FEATURE_NAMES.jserrors), crossFeatureData => {
-      crossFeatureData.hasReplay = !!(this.scheduler?.started && this.recorder && this.mode === MODE.FULL && !this.blocked && this.entitled);
-    });
 
     // 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.
     this.ee.on(SESSION_EVENTS.RESET, () => {
@@ -78,10 +75,13 @@ export class Aggregate extends AggregateBase {
     });
 
     // Bespoke logic for blobs endpoint.
-    this.scheduler = new HarvestScheduler('browser/blobs', {
-      onFinished: this.onHarvestFinished.bind(this),
+    this.scheduler = new HarvestScheduler(FEATURE_TO_ENDPOINT[this.featureName], {
+      onFinished: result => this.postHarvestCleanup(result),
       retryDelay: this.harvestTimeSeconds,
-      getPayload: this.prepareHarvest.bind(this),
+      getPayload: ({
+        retry,
+        ...opts
+      }) => this.makeHarvestPayload(retry, opts),
       raw: true
     }, this);
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
@@ -130,6 +130,9 @@ export class Aggregate extends AggregateBase {
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, FEATURE_NAMES.metrics, this.ee);
     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);
+  }
   handleError(e) {
     if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
     // run once
@@ -237,9 +240,7 @@ export class Aggregate extends AggregateBase {
       // compressor failed to load, but we can still record without compression as a last ditch effort
     }
   }
-  prepareHarvest({
-    opts
-  } = {}) {
+  makeHarvestPayload(shouldRetryOnFail, opts) {
     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
@@ -375,7 +376,7 @@ export class Aggregate extends AggregateBase {
       body: events
     };
   }
-  onHarvestFinished(result) {
+  postHarvestCleanup(result) {
     // The mutual decision for now is to stop recording and clear buffers if ingest is experiencing 429 rate limiting
     if (result.status === 429) {
       this.abort(ABORT_REASONS.TOO_MANY);