@newrelic/browser-agent 1.272.0 → 1.273.0

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

@@ -16,7 +16,6 @@ var _runtime = require("../../../common/constants/runtime");
 var _constants = require("../constants");
 var _features = require("../../../loaders/features/features");
 var _aggregateBase = require("../../utils/aggregate-base");
-var _nreum = require("../../../common/window/nreum");
 var _now = require("../../../common/timing/now");
 var _traverse = require("../../../common/util/traverse");
 var _internalErrors = require("./internal-errors");
@@ -38,7 +37,6 @@ class Aggregate extends _aggregateBase.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
@@ -48,14 +46,19 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (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
 
     // 0 == off, 1 == on
     this.waitForFlags(['err']).then(([errFlag]) => {
       if (errFlag) {
-        const scheduler = new _harvestScheduler.HarvestScheduler('jserrors', {
-          onFinished: (...args) => this.onHarvestFinished(...args)
+        const scheduler = new _harvestScheduler.HarvestScheduler(_features.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(_features.FEATURE_TO_ENDPOINT[this.featureName], options => this.makeHarvestPayload(options.retry, {
+          aggregatorTypes
+        }));
         scheduler.startTimer(harvestTimeSeconds);
         this.drain();
       } else {
@@ -64,49 +67,22 @@ class Aggregate extends _aggregateBase.AggregateBase {
       }
     });
   }
-  onHarvestStarted(options) {
-    // this gets rid of dependency in AJAX module
-    var body = (0, _traverse.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 = (0, _stringify.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 (0, _traverse.applyFnToProps)(aggregatorTypeToBucketsMap, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string');
+  }
+  queryStringsBuilder(aggregatorTakeReturnedData) {
+    const qs = {};
+    const releaseIds = (0, _stringify.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?.[_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 (0, _stringHashCode.stringHashCode)("".concat(params.exceptionClass, "_").concat(params.message, "_").concat(params.stack_trace || params.browser_stack_hash));
-  }
-  getBucketName(objType, params, customParams) {
-    if (objType === 'xhr') {
-      return (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(params)) + ':' + (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
-    }
-    return this.nameHash(params) + ':' + (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+    return qs;
   }
 
   /**
@@ -213,7 +189,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       params._interactionId = err.__newrelic[this.agentIdentifier].interactionId;
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId;
     }
-    const softNavInUse = Boolean((0, _nreum.getNREUMInitializedAgent)(this.agentIdentifier)?.features[_features.FEATURE_NAMES.softNav]);
+    const softNavInUse = Boolean(this.agentRef.features?.[_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) (0, _handle.handle)('jserror', [params, time], undefined, _features.FEATURE_NAMES.softNav, this.ee);else (0, _handle.handle)('spa-jserror', jsErrorEvent, undefined, _features.FEATURE_NAMES.spa, this.ee);
@@ -248,7 +224,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
 
     const jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.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' ? (0, _stringify.stringify)(val) : val;
     }
@@ -272,7 +248,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.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' ? (0, _stringify.stringify)(val) : val;
       }
@@ -285,27 +261,5 @@ class Aggregate extends _aggregateBase.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;
-      });
-    }
-  }
 }
 exports.Aggregate = Aggregate;

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

@@ -16,20 +16,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 _eventBuffer = require("../../utils/event-buffer");
+var _features = require("../../../loaders/features/features");
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants2.FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, _constants2.FEATURE_NAME);
-
-    /** held logs before sending */
-    this.bufferedLogs = new _eventBuffer.EventBuffer();
     this.harvestTimeSeconds = agentRef.init.logging.harvestTimeSeconds;
     this.waitForFlags([]).then(() => {
-      this.scheduler = new _harvestScheduler.HarvestScheduler('browser/logs', {
-        onFinished: this.onHarvestFinished.bind(this),
+      this.scheduler = new _harvestScheduler.HarvestScheduler(_features.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 */
@@ -62,64 +59,60 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const log = new _log.Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
     const logBytes = log.message.length + (0, _stringify.stringify)(log.attributes).length + log.level.length + 10; // timestamp == 10 chars
 
-    if (!this.bufferedLogs.canMerge(logBytes)) {
-      if (this.bufferedLogs.hasData) {
-        (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Early/Seen', this.bufferedLogs.bytes + logBytes]);
-        this.scheduler.runHarvest({});
-        if (logBytes < _agentConstants.MAX_PAYLOAD_SIZE) this.bufferedLogs.add(log);
-      } else {
-        (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', logBytes]);
-        (0, _console.warn)(31, log.message.slice(0, 25) + '...');
-      }
+    const failToHarvestMessage = 'Logging/Harvest/Failed/Seen';
+    if (logBytes > _agentConstants.MAX_PAYLOAD_SIZE) {
+      // cannot possibly send this, even with an empty buffer
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, [failToHarvestMessage, logBytes]);
+      (0, _console.warn)(31, log.message.slice(0, 25) + '...');
       return;
     }
-    this.bufferedLogs.add(log);
+    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
+    }
+    if (!this.events.add(log)) {
+      // still failed after a harvest attempt despite not being too large would mean harvest failed with options.retry
+      (0, _handle.handle)(_constants.SUPPORTABILITY_METRIC_CHANNEL, [failToHarvestMessage, logBytes]);
+      (0, _console.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: (0, _traverse.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: (0, _traverse.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
+    };
   }
 }
 exports.Aggregate = Aggregate;

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

@@ -13,6 +13,7 @@ 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'
@@ -21,15 +22,17 @@ 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.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('jserrors', {
+        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('jserrors', () => ({
-          body: this.agentRef.sharedAggregator.take(['cm', 'sm'])
+        scheduler.harvest.on(_features.FEATURE_TO_ENDPOINT[this.featureName], () => this.makeHarvestPayload(undefined, {
+          aggregatorTypes
         }));
         this.drain();
       } else {
@@ -50,7 +53,7 @@ class Aggregate extends _aggregateBase.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;
@@ -58,7 +61,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
     const params = {
       name
     };
-    this.agentRef.sharedAggregator.store(type, name, params, metrics);
+    this.events.add(type, name, params, metrics);
   }
   singleChecks() {
     // report loaderType

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

@@ -20,7 +20,6 @@ var _largestContentfulPaint = require("../../../common/vitals/largest-contentful
 var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
 var _pageVisibility = require("../../../common/window/page-visibility");
 var _constants2 = require("../../../common/vitals/constants");
-var _eventBuffer = require("../../utils/event-buffer");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -37,7 +36,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
   };
   constructor(agentRef) {
     super(agentRef, _constants.FEATURE_NAME);
-    this.timings = new _eventBuffer.EventBuffer();
     this.curSessEndRecorded = false;
     (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:
@@ -69,9 +67,9 @@ 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('events', {
-        onFinished: (...args) => this.onHarvestFinished(...args),
-        getPayload: (...args) => this.prepareHarvest(...args)
+      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();
@@ -104,16 +102,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (name !== _constants2.VITAL_NAMES.CUMULATIVE_LAYOUT_SHIFT && _cumulativeLayoutShift.cumulativeLayoutShift.current.value >= 0) {
       attrs.cls = _cumulativeLayoutShift.cumulativeLayoutShift.current.value;
     }
-    this.timings.add({
+    this.events.add({
       name,
       value,
       attrs
     });
     (0, _handle.handle)('pvtAdded', [name, value, attrs], undefined, _features.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'];
@@ -124,24 +119,12 @@ class Aggregate extends _aggregateBase.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 = (0, _belSerializer.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 += (0, _belSerializer.nullable)(timing.value, _belSerializer.numeric, false) + ',';
@@ -150,7 +133,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (attrParts && attrParts.length > 0) {
         payload += (0, _belSerializer.numeric)(attrParts.length) + ';' + attrParts.join(';');
       }
-      if (i + 1 < data.length) payload += ';';
+      if (i + 1 < eventBuffer.length) payload += ';';
     }
     return payload;
   }

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

@@ -55,9 +55,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.recorder = args?.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
-    this.ee.on("cfc.".concat(_features.FEATURE_NAMES.jserrors), crossFeatureData => {
-      crossFeatureData.hasReplay = !!(this.scheduler?.started && this.recorder && this.mode === _constants3.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(_constants3.SESSION_EVENTS.RESET, () => {
@@ -83,10 +80,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
     });
 
     // Bespoke logic for blobs endpoint.
-    this.scheduler = new _harvestScheduler.HarvestScheduler('browser/blobs', {
-      onFinished: this.onHarvestFinished.bind(this),
+    this.scheduler = new _harvestScheduler.HarvestScheduler(_features.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);
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.PAUSE, () => {
@@ -135,6 +135,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/SamplingRate/Value', sampling_rate], undefined, _features.FEATURE_NAMES.metrics, this.ee);
     (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);
+  }
   handleError(e) {
     if (this.recorder) this.recorder.currentBufferTarget.hasError = true;
     // run once
@@ -242,9 +245,7 @@ class Aggregate extends _aggregateBase.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
@@ -380,7 +381,7 @@ class Aggregate extends _aggregateBase.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(_constants.ABORT_REASONS.TOO_MANY);

package/dist/cjs/features/session_replay/shared/recorder-events.js

@@ -27,12 +27,12 @@ class RecorderEvents {
     this.#events.add(event);
   }
   get events() {
-    return this.#events.buffer;
+    return this.#events.get();
   }
 
   /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
   get payloadBytesEstimation() {
-    return this.#events.bytes;
+    return this.#events.byteSize();
   }
 }
 exports.RecorderEvents = RecorderEvents;