@newrelic/browser-agent 1.301.0 → 1.302.0-alpha.1

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

@@ -33,6 +33,13 @@ export class Instrument extends InstrumentBase {
     setupFinishedAPI(agentRef);
     setupRegisterAPI(agentRef);
     setupMeasureAPI(agentRef);
+    const ufEnabled = agentRef.init.feature_flags.includes('user_frustrations');
+    let historyEE;
+    if (isBrowserScope && ufEnabled) {
+      wrapFetch(this.ee);
+      wrapXhr(this.ee);
+      historyEE = wrapHistory(this.ee);
+    }
     if (isBrowserScope) {
       if (agentRef.init.user_actions.enabled) {
         OBSERVED_EVENTS.forEach(eventType => windowAddEventListener(eventType, evt => handle('ua', [evt], undefined, this.featureName, this.ee), true));
@@ -46,6 +53,37 @@ export class Instrument extends InstrumentBase {
         }
         // Capture is not used here so that we don't get element focus/blur events, only the window's as they do not bubble. They are also not cancellable, so no worries about being front of line.
         );
+        if (ufEnabled) {
+          globalScope.addEventListener('error', () => {
+            handle('uaErr', [], undefined, FEATURE_NAMES.genericEvents, this.ee);
+          }, eventListenerOpts(false, this.removeOnAbort?.signal));
+          this.ee.on('open-xhr-start', (args, xhr) => {
+            if (!isInternalTraffic(args[1])) {
+              xhr.addEventListener('readystatechange', () => {
+                if (xhr.readyState === 2) {
+                  // HEADERS_RECEIVED
+                  handle('uaXhr', [], undefined, FEATURE_NAMES.genericEvents, this.ee);
+                }
+              });
+            }
+          });
+          this.ee.on('fetch-start', fetchArguments => {
+            if (fetchArguments.length >= 1 && !isInternalTraffic(extractUrl(fetchArguments[0]))) {
+              handle('uaXhr', [], undefined, FEATURE_NAMES.genericEvents, this.ee);
+            }
+          });
+          function isInternalTraffic(url) {
+            const parsedUrl = parseUrl(url);
+            return agentRef.beacons.includes(parsedUrl.hostname + ':' + parsedUrl.port);
+          }
+          historyEE.on('pushState-end', navigationChange);
+          historyEE.on('replaceState-end', navigationChange);
+          window.addEventListener('hashchange', navigationChange, eventListenerOpts(true, this.removeOnAbort?.signal));
+          window.addEventListener('popstate', navigationChange, eventListenerOpts(true, this.removeOnAbort?.signal));
+          function navigationChange() {
+            historyEE.emit('navChange');
+          }
+        }
       }
       if (agentRef.init.performance.resources.enabled && globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
         const observer = new PerformanceObserver(list => {
@@ -58,14 +96,6 @@ export class Instrument extends InstrumentBase {
           buffered: true
         });
       }
-      const historyEE = wrapHistory(this.ee);
-      historyEE.on('pushState-end', navigationChange);
-      historyEE.on('replaceState-end', navigationChange);
-      window.addEventListener('hashchange', navigationChange, eventListenerOpts(true, this.removeOnAbort?.signal));
-      window.addEventListener('popstate', navigationChange, eventListenerOpts(true, this.removeOnAbort?.signal));
-      function navigationChange() {
-        historyEE.emit('navChange');
-      }
     }
     try {
       this.removeOnAbort = new AbortController();
@@ -74,30 +104,6 @@ export class Instrument extends InstrumentBase {
       this.removeOnAbort?.abort();
       this.abortHandler = undefined; // weakly allow this abort op to run only once
     };
-    globalScope.addEventListener('error', () => {
-      handle('uaErr', [], undefined, FEATURE_NAMES.genericEvents, this.ee);
-    }, eventListenerOpts(false, this.removeOnAbort?.signal));
-    wrapFetch(this.ee);
-    wrapXhr(this.ee);
-    this.ee.on('open-xhr-start', (args, xhr) => {
-      if (!isInternalTraffic(args[1])) {
-        xhr.addEventListener('readystatechange', () => {
-          if (xhr.readyState === 2) {
-            // HEADERS_RECEIVED
-            handle('uaXhr', [], undefined, FEATURE_NAMES.genericEvents, this.ee);
-          }
-        });
-      }
-    });
-    this.ee.on('fetch-start', fetchArguments => {
-      if (fetchArguments.length >= 1 && !isInternalTraffic(extractUrl(fetchArguments[0]))) {
-        handle('uaXhr', [], undefined, FEATURE_NAMES.genericEvents, this.ee);
-      }
-    });
-    function isInternalTraffic(url) {
-      const parsedUrl = parseUrl(url);
-      return agentRef.beacons.includes(parsedUrl.hostname + ':' + parsedUrl.port);
-    }
 
     /** If any of the sources are active, import the aggregator. otherwise deregister */
     if (genericEventSourceConfigs.some(x => x)) this.importAggregator(agentRef, () => import(/* webpackChunkName: "generic_events-aggregate" */'../aggregate'));else this.deregisterDrain();

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

@@ -17,8 +17,7 @@ import { AggregateBase } from '../../utils/aggregate-base';
 import { now } from '../../../common/timing/now';
 import { applyFnToProps } from '../../../common/util/traverse';
 import { evaluateInternalError } from './internal-errors';
-import { isContainerAgentTarget } from '../../../common/util/target';
-import { warn } from '../../../common/util/console';
+import { getVersion2Attributes } from '../../../common/util/mfe';
 import { buildCauseString } from './cause-string';
 
 /**
@@ -29,6 +28,9 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
+
+    /** set up agg-level behaviors specific to this feature */
+    this.harvestOpts.aggregatorTypes = ['err', 'ierr', 'xhr']; // the types in EventAggregator this feature cares about
     this.stackReported = {};
     this.observedAt = {};
     this.pageviewReported = {};
@@ -41,8 +43,6 @@ export class Aggregate extends AggregateBase {
     register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee);
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs, interactionEndTime) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs, interactionEndTime), this.featureName, this.ee); // when an ixn is done or cancelled
 
-    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) {
@@ -102,10 +102,8 @@ export class Aggregate extends AggregateBase {
    * @param {object=} target the target to buffer and harvest to, if undefined the default configuration target is used
    * @returns
    */
-  storeError(err, time, internal, customAttributes, hasReplay, swallowReason, targetEntityGuid) {
+  storeError(err, time, internal, customAttributes, hasReplay, swallowReason, target) {
     if (!err) return;
-    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
-    if (!target) return warn(56, this.featureName);
     // are we in an interaction
     time = time || now();
     let filterOutput;
@@ -143,7 +141,7 @@ export class Aggregate extends AggregateBase {
     if (filterOutput?.group) params.errorGroup = filterOutput.group;
 
     // Should only decorate "hasReplay" for the container agent, so check if the target matches the config
-    if (hasReplay && isContainerAgentTarget(target, this.agentRef)) params.hasReplay = hasReplay;
+    if (hasReplay && !target) params.hasReplay = hasReplay;
     /**
      * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
      * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
@@ -178,14 +176,14 @@ export class Aggregate extends AggregateBase {
 
     // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
     const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes];
-    if (this.shouldAllowMainAgentToCapture(targetEntityGuid)) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee);
+    if (this.shouldAllowMainAgentToCapture(target)) handle('trace-jserror', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee);
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;
     if (err?.__newrelic?.[this.agentIdentifier]) {
       params._interactionId = err.__newrelic[this.agentIdentifier].interactionId;
       params._interactionNodeId = err.__newrelic[this.agentIdentifier].interactionNodeId;
     }
-    if (this.shouldAllowMainAgentToCapture(targetEntityGuid)) {
+    if (this.shouldAllowMainAgentToCapture(target)) {
       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.
@@ -206,11 +204,14 @@ export class Aggregate extends AggregateBase {
     }
 
     // always add directly if scoped to a sub-entity, the other pathways above will be deterministic if the main agent should procede
-    if (targetEntityGuid) this.#storeJserrorForHarvest([...jsErrorEvent, targetEntityGuid], false, params._softNavAttributes);
+    if (target) this.#storeJserrorForHarvest([...jsErrorEvent, target], false, params._softNavAttributes);
   }
   #storeJserrorForHarvest(errorInfoArr, softNavOccurredFinished, softNavCustomAttrs = {}) {
-    let [type, bucketHash, params, newMetrics, localAttrs, targetEntityGuid] = errorInfoArr;
-    const allCustomAttrs = {};
+    let [type, bucketHash, params, newMetrics, localAttrs, target] = errorInfoArr;
+    const allCustomAttrs = {
+      /** MFE specific attributes if in "multiple" mode (ie consumer version 2) */
+      ...getVersion2Attributes(target, this)
+    };
     if (softNavOccurredFinished) {
       Object.entries(softNavCustomAttrs).forEach(([k, v]) => setCustom(k, v)); // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
       bucketHash += params.browserInteractionId;
@@ -225,7 +226,7 @@ export class Aggregate extends AggregateBase {
 
     const jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
     const aggregateHash = bucketHash + ':' + jsAttributesHash;
-    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs], targetEntityGuid);
+    this.events.add([type, aggregateHash, params, newMetrics, allCustomAttrs]);
     function setCustom(key, val) {
       allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
     }
@@ -234,11 +235,11 @@ export class Aggregate extends AggregateBase {
   /**
   * If the event lacks an entityGuid (the default behavior), the main agent should capture the data. If the data is assigned to a sub-entity target
   * the main agent should not capture events unless it is configured to do so.
-  * @param {string} entityGuid - the context object for the event
+  * @param {string} target - the context object for the event
   * @returns {boolean} - whether the main agent should capture the event to its internal target
   */
-  shouldAllowMainAgentToCapture(entityGuid) {
-    return !entityGuid || this.agentRef.init.api.duplicate_registered_data;
+  shouldAllowMainAgentToCapture(target) {
+    return !target || this.agentRef.init.api.duplicate_registered_data;
   }
 
   // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.

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

@@ -10,15 +10,18 @@ import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS, LOGGING_MODE }
 import { Log } from '../shared/log';
 import { isValidLogLevel } from '../shared/utils';
 import { applyFnToProps } from '../../../common/util/traverse';
-import { isContainerAgentTarget } from '../../../common/util/target';
 import { SESSION_EVENT_TYPES, SESSION_EVENTS } from '../../../common/session/constants';
 import { ABORT_REASONS } from '../../session_replay/constants';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
+import { getVersion2Attributes } from '../../../common/util/mfe';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentRef) {
     super(agentRef, FEATURE_NAME);
     this.isSessionTrackingEnabled = canEnableSessionTracking(agentRef.init) && agentRef.runtime.session;
+
+    /** set up agg-level behaviors specific to this feature */
+    this.harvestOpts.raw = true;
     super.customAttributesAreSeparate = true;
 
     // 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.
@@ -29,7 +32,6 @@ export class Aggregate extends AggregateBase {
       if (this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return;
       if (this.loggingMode !== LOGGING_MODE.OFF && data.loggingMode === LOGGING_MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);else this.loggingMode = data.loggingMode;
     });
-    this.harvestOpts.raw = true;
     this.waitForFlags(['log']).then(([loggingMode]) => {
       const session = this.agentRef.runtime.session ?? {};
       if (this.loggingMode === LOGGING_MODE.OFF || session.isNew && loggingMode === LOGGING_MODE.OFF) {
@@ -56,10 +58,14 @@ export class Aggregate extends AggregateBase {
       loggingMode: this.loggingMode
     });
   }
-  handleLog(timestamp, message, attributes = {}, level = LOG_LEVELS.INFO, targetEntityGuid) {
-    if (!this.agentRef.runtime.entityManager.get(targetEntityGuid)) return warn(56, this.featureName);
+  handleLog(timestamp, message, attributes = {}, level = LOG_LEVELS.INFO, target) {
     if (this.blocked || !this.loggingMode) return;
     if (!attributes || typeof attributes !== 'object') attributes = {};
+    attributes = {
+      ...attributes,
+      /** Specific attributes only supplied if harvesting to endpoint version 2 */
+      ...getVersion2Attributes(target, this)
+    };
     if (typeof level === 'string') level = level.toUpperCase();
     if (!isValidLogLevel(level)) return warn(30, level);
     if (this.loggingMode < (LOGGING_MODE[level] || Infinity)) {
@@ -83,10 +89,9 @@ export class Aggregate extends AggregateBase {
     }
     if (typeof message !== 'string' || !message) return warn(32);
     const log = new Log(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(timestamp)), message, attributes, level);
-    this.events.add(log, targetEntityGuid);
+    this.events.add(log);
   }
-  serializer(eventBuffer, targetEntityGuid) {
-    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
+  serializer(eventBuffer) {
     const sessionEntity = this.agentRef.runtime.session;
     return [{
       common: {
@@ -94,19 +99,19 @@ export class Aggregate extends AggregateBase {
         attributes: {
           ...this.agentRef.info.jsAttributes,
           // user-provided custom attributes
-          'entity.guid': target.entityGuid,
-          // browser entity guid as provided API target OR the default from RUM response if not supplied
+          ...(this.harvestEndpointVersion === 1 && {
+            'entity.guid': this.agentRef.runtime.appMetadata.agents[0].entityGuid,
+            appId: this.agentRef.info.applicationID
+          }),
           ...(sessionEntity && {
             session: sessionEntity.state.value || '0',
             // The session ID that we generate and keep across page loads
-            hasReplay: sessionEntity.state.sessionReplayMode === 1 && isContainerAgentTarget(target, this.agentRef),
+            hasReplay: sessionEntity.state.sessionReplayMode === 1,
             // True if a session replay recording is running
             hasTrace: sessionEntity.state.sessionTraceMode === 1 // True if a session trace recording is running
           }),
           ptid: this.agentRef.runtime.ptid,
           // page trace id
-          appId: target.applicationID || 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,
@@ -121,10 +126,9 @@ export class Aggregate extends AggregateBase {
       logs: applyFnToProps(eventBuffer, this.obfuscator.obfuscateString.bind(this.obfuscator), 'string')
     }];
   }
-  queryStringsBuilder(_, targetEntityGuid) {
-    const target = this.agentRef.runtime.entityManager.get(targetEntityGuid);
+  queryStringsBuilder() {
     return {
-      browser_monitoring_key: target.licenseKey
+      browser_monitoring_key: this.agentRef.info.licenseKey
     };
   }
 

package/dist/esm/features/logging/shared/utils.js

@@ -13,11 +13,11 @@ import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants';
    * @param {string} message - the log message string
    * @param {{[key: string]: *}} customAttributes - The log's custom attributes if any
    * @param {enum} level - the log level enum
-   * @param {object=} targetEntityGuid - the optional target entity guid provided by an api call
+   * @param {object=} target - the optional target provided by an api call
    */
-export function bufferLog(ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, targetEntityGuid, timestamp = now()) {
+export function bufferLog(ee, message, customAttributes = {}, level = LOG_LEVELS.INFO, target, timestamp = now()) {
   handle(SUPPORTABILITY_METRIC_CHANNEL, ["API/logging/".concat(level.toLowerCase(), "/called")], undefined, FEATURE_NAMES.metrics, ee);
-  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, targetEntityGuid], undefined, FEATURE_NAMES.logging, ee);
+  handle(LOGGING_EVENT_EMITTER_CHANNEL, [timestamp, message, customAttributes, level, target], undefined, FEATURE_NAMES.logging, ee);
 }
 
 /**

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

@@ -17,8 +17,9 @@ import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
 import { now } from '../../../common/timing/now';
 import { TimeKeeper } from '../../../common/timing/time-keeper';
 import { applyFnToProps } from '../../../common/util/traverse';
-import { registerHandler } from '../../../common/event-emitter/register-handler';
-import { isContainerAgentTarget } from '../../../common/util/target';
+import { send } from '../../../common/harvest/harvester';
+import { FEATURE_NAMES, FEATURE_TO_ENDPOINT } from '../../../loaders/features/features';
+import { getSubmitMethod } from '../../../common/util/submit-data';
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentRef) {
@@ -27,9 +28,6 @@ export class Aggregate extends AggregateBase {
     this.firstByteToWindowLoad = 0; // our "frontend" duration
     this.firstByteToDomContent = 0; // our "dom processing" duration
 
-    registerHandler('send-rum', (customAttibutes, target) => {
-      this.sendRum(customAttibutes, target);
-    }, this.featureName, this.ee);
     if (!isValid(agentRef.info)) {
       this.ee.abort();
       return warn(43);
@@ -57,7 +55,7 @@ export class Aggregate extends AggregateBase {
    *
    * @param {Function} cb A function to run once the RUM call has finished - Defaults to activateFeatures
    * @param {*} customAttributes custom attributes to attach to the RUM call - Defaults to info.js
-   * @param {*} target The target to harvest to - Since we will not know the entityGuid before harvesting, this must be an object directly supplied from the info object or API, not an entityGuid string for lookup with the entityManager - Defaults to { licenseKey: this.agentRef.info.licenseKey, applicationID: this.agentRef.info.applicationID }
+   * @param {*} target The target to harvest to
    */
   sendRum(customAttributes = this.agentRef.info.jsAttributes, target = {
     licenseKey: this.agentRef.info.licenseKey,
@@ -120,7 +118,7 @@ export class Aggregate extends AggregateBase {
     this.rumStartTime = now();
     this.agentRef.runtime.harvester.triggerHarvestFor(this, {
       directSend: {
-        targetApp: target,
+        target,
         payload: {
           qs: queryParameters,
           body
@@ -133,8 +131,7 @@ export class Aggregate extends AggregateBase {
   postHarvestCleanup({
     status,
     responseText,
-    xhr,
-    targetApp
+    xhr
   }) {
     const rumEndTime = now();
     let app, flags;
@@ -143,16 +140,57 @@ export class Aggregate extends AggregateBase {
         app,
         ...flags
       } = JSON.parse(responseText));
-      this.processEntities(app.agents, targetApp);
     } catch (error) {
       // wont set entity stuff here, if main agent will later abort, if registered agent, nothing will happen
       warn(53, error);
     }
-
-    /** Only run agent-wide side-effects if the harvest was for the main agent */
-    if (!isContainerAgentTarget(targetApp, this.agentRef)) return;
     if (status >= 400 || status === 0) {
       warn(18, status);
+
+      // Get estimated payload size of our backlog
+      const textEncoder = new TextEncoder();
+      const payloadSize = Object.values(newrelic.ee.backlog).reduce((acc, value) => {
+        if (!value) return acc;
+        const encoded = textEncoder.encode(value);
+        return acc + encoded.byteLength;
+      }, 0);
+
+      // Send SMs about failed RUM request
+      const body = {
+        sm: [{
+          params: {
+            name: "Browser/Supportability/BCS/Error/".concat(status)
+          },
+          stats: {
+            c: 1
+          }
+        }, {
+          params: {
+            name: 'Browser/Supportability/BCS/Error/Dropped/Bytes'
+          },
+          stats: {
+            c: 1,
+            t: payloadSize
+          }
+        }, {
+          params: {
+            name: 'Browser/Supportability/BCS/Error/Duration/Ms'
+          },
+          stats: {
+            c: 1,
+            t: rumEndTime - this.rumStartTime
+          }
+        }]
+      };
+      send(this.agentRef, {
+        endpoint: FEATURE_TO_ENDPOINT[FEATURE_NAMES.metrics],
+        payload: {
+          body
+        },
+        submitMethod: getSubmitMethod(),
+        featureName: FEATURE_NAMES.metrics
+      });
+
       // Adding retry logic for the rum call will be a separate change; this.blocked will need to be changed since that prevents another triggerHarvestFor()
       this.ee.abort();
       return;
@@ -181,24 +219,4 @@ export class Aggregate extends AggregateBase {
     this.agentRef.runtime.harvester.startTimer();
     activateFeatures(flags, this.agentRef);
   }
-  processEntities(entities, targetApp) {
-    if (!entities || !targetApp) return;
-    entities.forEach(agent => {
-      const entityManager = this.agentRef.runtime.entityManager;
-      const entityGuid = agent.entityGuid;
-      const entity = entityManager.get(entityGuid);
-      if (entity) return; // already processed
-
-      if (isContainerAgentTarget(targetApp, this.agentRef)) {
-        entityManager.setDefaultEntity({
-          ...targetApp,
-          entityGuid
-        });
-      }
-      entityManager.set(agent.entityGuid, {
-        ...targetApp,
-        entityGuid
-      });
-    });
-  }
 }

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

@@ -7,7 +7,7 @@
  */
 
 import { registerHandler } from '../../../common/event-emitter/register-handler';
-import { ABORT_REASONS, FEATURE_NAME, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants';
+import { ABORT_REASONS, ERROR_DURING_REPLAY, FEATURE_NAME, QUERY_PARAM_PADDING, RRWEB_EVENT_TYPES, TRIGGERS } from '../constants';
 import { AggregateBase } from '../../utils/aggregate-base';
 import { sharedChannel } from '../../../common/constants/shared-channel';
 import { obj as encodeObj } from '../../../common/url/encode';
@@ -21,6 +21,7 @@ import { now } from '../../../common/timing/now';
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
 import { cleanURL } from '../../../common/url/clean-url';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
+import { PAUSE_REPLAY } from '../../../loaders/api/constants';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   mode = MODE.OFF;
@@ -36,6 +37,8 @@ export class Aggregate extends AggregateBase {
     this.gzipper = undefined;
     /** populated with the u8 string lib async */
     this.u8 = undefined;
+    /** flips to false if the compressor libraries cannot import */
+    this.shouldCompress = true;
 
     /** set by BCS response */
     this.entitled = false;
@@ -70,10 +73,10 @@ export class Aggregate extends AggregateBase {
       if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB);
       this.mode = data.sessionReplayMode;
     });
-    registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
+    registerHandler(PAUSE_REPLAY, () => {
       this.forceStop(this.mode === MODE.FULL);
     }, this.featureName, this.ee);
-    registerHandler(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
+    registerHandler(ERROR_DURING_REPLAY, e => {
       this.handleError(e);
     }, this.featureName, this.ee);
     const {
@@ -207,23 +210,22 @@ export class Aggregate extends AggregateBase {
       this.gzipper = gzipSync;
       this.u8 = strToU8;
     } catch (err) {
-      // compressor failed to load, but we can still record without compression as a last ditch effort
+      this.shouldCompress = false;
+      // compressor failed to load, but we can still try to record without compression as a last ditch effort
     }
   }
-  makeHarvestPayload(shouldRetryOnFail) {
-    const payloadOutput = {
-      targetApp: undefined,
-      payload: undefined
-    };
-    if (this.mode !== MODE.FULL || this.blocked) return;
-    if (!this.recorder || !this.timeKeeper?.ready || !this.recorder.hasSeenSnapshot) return;
+  makeHarvestPayload() {
+    if (this.mode !== MODE.FULL || this.blocked) return; // harvests should only be made in FULL mode, and not if the feature is blocked
+    if (this.shouldCompress && !this.gzipper) return; // if compression is enabled, but the libraries have not loaded, wait for them to load
+    if (!this.recorder || !this.timeKeeper?.ready || !(this.recorder.hasSeenSnapshot && this.recorder.hasSeenMeta)) return; // if the recorder or the timekeeper is not ready, or the recorder has not yet seen a snapshot, do not harvest
+
     const recorderEvents = this.recorder.getEvents();
     // get the event type and use that to trigger another harvest if needed
     if (!recorderEvents.events.length) return;
     const payload = this.getHarvestContents(recorderEvents);
     if (!payload.body.length) {
       this.recorder.clearBuffer();
-      return [payloadOutput];
+      return;
     }
     this.reportSupportabilityMetric('SessionReplay/Harvest/Attempts');
     let len = 0;
@@ -238,19 +240,18 @@ export class Aggregate extends AggregateBase {
     }
     if (len > MAX_PAYLOAD_SIZE) {
       this.abort(ABORT_REASONS.TOO_BIG, len);
-      return [payloadOutput];
+      return;
     }
+
     // TODO -- Gracefully handle the buffer for retries.
     if (!this.agentRef.runtime.session.state.sessionReplaySentFirstChunk) this.syncWithSessionManager({
       sessionReplaySentFirstChunk: true
     });
     this.recorder.clearBuffer();
-    if (recorderEvents.type === 'preloaded') this.agentRef.runtime.harvester.triggerHarvestFor(this);
-    payloadOutput.payload = payload;
     if (!this.agentRef.runtime.session.state.traceHarvestStarted) {
       warn(59, JSON.stringify(this.agentRef.runtime.session.state));
     }
-    return [payloadOutput];
+    return payload;
   }
 
   /**

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

@@ -5,11 +5,7 @@
 import { MODE } from '../../common/session/constants';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 export const FEATURE_NAME = FEATURE_NAMES.sessionReplay;
-export const SR_EVENT_EMITTER_TYPES = {
-  RECORD: 'recordReplay',
-  PAUSE: 'pauseReplay',
-  ERROR_DURING_REPLAY: 'errorDuringReplay'
-};
+export const ERROR_DURING_REPLAY = 'errorDuringReplay';
 export const AVG_COMPRESSION = 0.12;
 export const RRWEB_EVENT_TYPES = {
   DomContentLoaded: 0,

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

@@ -10,9 +10,10 @@ import { handle } from '../../../common/event-emitter/handle';
 import { DEFAULT_KEY, MODE, PREFIX } from '../../../common/session/constants';
 import { InstrumentBase } from '../../utils/instrument-base';
 import { hasReplayPrerequisite, isPreloadAllowed } from '../shared/utils';
-import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES, TRIGGERS } from '../constants';
+import { ERROR_DURING_REPLAY, FEATURE_NAME, TRIGGERS } from '../constants';
 import { setupRecordReplayAPI } from '../../../loaders/api/recordReplay';
 import { setupPauseReplayAPI } from '../../../loaders/api/pauseReplay';
+import { RECORD_REPLAY } from '../../../loaders/api/constants';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
   /** @type {Promise|undefined} A promise that resolves when the recorder module is imported and added to the class. Undefined if the recorder has never been staged to import with `importRecorder`. */
@@ -30,7 +31,7 @@ export class Instrument extends InstrumentBase {
       session = JSON.parse(localStorage.getItem("".concat(PREFIX, "_").concat(DEFAULT_KEY)));
     } catch (err) {}
     if (hasReplayPrerequisite(agentRef.init)) {
-      this.ee.on(SR_EVENT_EMITTER_TYPES.RECORD, () => this.#apiStartOrRestartReplay());
+      this.ee.on(RECORD_REPLAY, () => this.#apiStartOrRestartReplay());
     }
     if (this.#canPreloadRecorder(session)) {
       this.importRecorder().then(recorder => {
@@ -44,7 +45,7 @@ export class Instrument extends InstrumentBase {
       if (this.blocked) return;
       if (this.agentRef.runtime.isRecording) {
         this.errorNoticed = true;
-        handle(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee);
+        handle(ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee);
       }
     });
   }

package/dist/esm/features/session_replay/shared/recorder.js

@@ -42,6 +42,7 @@ export class Recorder {
     this.backloggedEvents = new RecorderEvents(this.shouldFix);
     /** Only set to true once a snapshot node has been processed.  Used to block harvests from sending before we know we have a snapshot */
     this.hasSeenSnapshot = false;
+    this.hasSeenMeta = false;
     /** Hold on to the last meta node, so that it can be re-inserted if the meta and snapshot nodes are broken up due to harvesting */
     this.lastMeta = false;
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
@@ -196,9 +197,9 @@ export class Recorder {
     }
 
     // meta event
-    this.events.hasMeta ||= event.type === RRWEB_EVENT_TYPES.Meta;
+    this.hasSeenMeta ||= this.events.hasMeta ||= event.type === RRWEB_EVENT_TYPES.Meta;
     // snapshot event
-    this.events.hasSnapshot ||= this.hasSeenSnapshot ||= event.type === RRWEB_EVENT_TYPES.FullSnapshot;
+    this.hasSeenSnapshot ||= this.events.hasSnapshot ||= event.type === RRWEB_EVENT_TYPES.FullSnapshot;
 
     //* dont let the EventBuffer class double evaluate the event data size, it's a performance burden and we have special reasons to do it outside the event buffer */
     this.events.add(event, eventBytes);

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

@@ -92,8 +92,6 @@ export class Aggregate extends AggregateBase {
       sessionTraceMode: this.mode
     });
     this.drain();
-    /** try to harvest immediately. This will not send if the trace is not running in FULL mode due to the pre-harvest checks. */
-    this.agentRef.runtime.harvester.triggerHarvestFor(this);
   }
   preHarvestChecks() {
     if (this.blocked || this.mode !== MODE.FULL) return; // only allow harvest if running in full mode

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

@@ -46,7 +46,6 @@ export class Aggregate extends AggregateBase {
     this.waitForFlags(['spa']).then(([spaOn]) => {
       if (spaOn) {
         this.drain();
-        setTimeout(() => agentRef.runtime.harvester.triggerHarvestFor(this), 0); // send the IPL ixn on next tick, giving some time for any ajax to finish; we may want to just remove this?
       } else {
         this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
         this.deregisterDrain();
@@ -141,7 +140,7 @@ export class Aggregate extends AggregateBase {
     */
     if (this.interactionInProgress?.isActiveDuring(timestamp)) return this.interactionInProgress;
     let saveIxn;
-    const interactionsBuffer = this.interactionsToHarvest.get()?.[0]?.data;
+    const interactionsBuffer = this.interactionsToHarvest.get();
     if (!interactionsBuffer) return undefined; // no interactions have been staged yet, so nothing to search through)
     for (let idx = interactionsBuffer.length - 1; idx >= 0; idx--) {
       // reverse search for the latest completed interaction for efficiency