@newrelic/browser-agent 1.296.0 → 1.297.0-rc.1

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

@@ -11,18 +11,13 @@ import { stylesheetEvaluator } from './stylesheet-evaluator';
 import { handle } from '../../../common/event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
-import { buildNRMetaNode, customMasker } from './utils';
+import { customMasker } from './utils';
 import { IDEAL_PAYLOAD_SIZE } from '../../../common/constants/agent-constants';
-import { AggregateBase } from '../../utils/aggregate-base';
 import { warn } from '../../../common/util/console';
 import { single } from '../../../common/util/invoke';
+import { registerHandler } from '../../../common/event-emitter/register-handler';
+const RRWEB_DATA_CHANNEL = 'rrweb-data';
 export class Recorder {
-  /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
-  #events;
-  /** Backlog used for a 2-part sliding window to guarantee a 15-30s buffer window */
-  #backloggedEvents;
-  /** array of recorder events -- Will be filled only if forced harvest was triggered and harvester does not exist */
-  #preloaded;
   /** flag that if true, blocks events from being "stored".  Only set to true when a full snapshot has incomplete nodes (only stylesheets ATM) */
   #fixing = false;
   #warnCSSOnce = single(() => warn(47)); // notifies user of potential replayer issue if fix_stylesheets is off
@@ -32,13 +27,12 @@ export class Recorder {
     this.parent = parent;
     /** A flag that can be set to false by failing conversions to stop the fetching process */
     this.shouldFix = this.parent.agentRef.init.session_replay.fix_stylesheets;
-    /** Event Buffers */
-    this.#events = new RecorderEvents(this.shouldFix);
-    this.#backloggedEvents = new RecorderEvents(this.shouldFix);
-    this.#preloaded = [new RecorderEvents(this.shouldFix)];
-    /** The pointer to the current bucket holding rrweb events */
-    this.currentBufferTarget = this.#events;
-    /** Only set to true once a snapshot node has been processed.  Used to block preload harvests from sending before we know we have a snapshot */
+
+    /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
+    this.events = new RecorderEvents(this.shouldFix);
+    /** Backlog used for a 2-part sliding window to guarantee a 15-30s buffer window */
+    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;
     /** 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;
@@ -46,32 +40,27 @@ export class Recorder {
     this.stopRecording = () => {
       this.parent.agentRef.runtime.isRecording = false;
     };
+    registerHandler(RRWEB_DATA_CHANNEL, (event, isCheckout) => {
+      this.audit(event, isCheckout);
+    }, this.parent.featureName, this.parent.ee);
   }
   getEvents() {
-    if (this.#preloaded[0]?.events.length) {
-      return {
-        ...this.#preloaded[0],
-        events: this.#preloaded[0].events,
-        payloadBytesEstimation: this.#preloaded[0].payloadBytesEstimation,
-        type: 'preloaded'
-      };
-    }
     return {
-      events: [...this.#backloggedEvents.events, ...this.#events.events].filter(x => x),
+      events: [...this.backloggedEvents.events, ...this.events.events].filter(x => x),
       type: 'standard',
-      cycleTimestamp: Math.min(this.#backloggedEvents.cycleTimestamp, this.#events.cycleTimestamp),
-      payloadBytesEstimation: this.#backloggedEvents.payloadBytesEstimation + this.#events.payloadBytesEstimation,
-      hasError: this.#backloggedEvents.hasError || this.#events.hasError,
-      hasMeta: this.#backloggedEvents.hasMeta || this.#events.hasMeta,
-      hasSnapshot: this.#backloggedEvents.hasSnapshot || this.#events.hasSnapshot,
-      inlinedAllStylesheets: !!this.#backloggedEvents.events.length && this.#backloggedEvents.inlinedAllStylesheets || this.#events.inlinedAllStylesheets
+      cycleTimestamp: Math.min(this.backloggedEvents.cycleTimestamp, this.events.cycleTimestamp),
+      payloadBytesEstimation: this.backloggedEvents.payloadBytesEstimation + this.events.payloadBytesEstimation,
+      hasError: this.backloggedEvents.hasError || this.events.hasError,
+      hasMeta: this.backloggedEvents.hasMeta || this.events.hasMeta,
+      hasSnapshot: this.backloggedEvents.hasSnapshot || this.events.hasSnapshot,
+      inlinedAllStylesheets: !!this.backloggedEvents.events.length && this.backloggedEvents.inlinedAllStylesheets || this.events.inlinedAllStylesheets
     };
   }
 
-  /** Clears the buffer (this.#events), and resets all payload metadata properties */
+  /** Clears the buffer (this.events), and resets all payload metadata properties */
   clearBuffer() {
-    if (this.#preloaded[0]?.events.length) this.#preloaded.shift();else if (this.parent.mode === MODE.ERROR) this.#backloggedEvents = this.#events;else this.#backloggedEvents = new RecorderEvents(this.shouldFix);
-    this.#events = new RecorderEvents(this.shouldFix);
+    this.backloggedEvents = this.parent.mode === MODE.ERROR ? this.events : new RecorderEvents(this.shouldFix);
+    this.events = new RecorderEvents(this.shouldFix);
   }
 
   /** Begin recording using configured recording lib */
@@ -94,7 +83,9 @@ export class Recorder {
     let stop;
     try {
       stop = recorder({
-        emit: this.audit.bind(this),
+        emit: (event, isCheckout) => {
+          handle(RRWEB_DATA_CHANNEL, [event, isCheckout], undefined, this.parent.featureName, this.parent.ee);
+        },
         blockClass: block_class,
         ignoreClass: ignore_class,
         maskTextClass: mask_text_class,
@@ -132,7 +123,7 @@ export class Recorder {
     /** only run the full fixing behavior (more costly) if fix_stylesheets is configured as on (default behavior) */
     if (!this.shouldFix) {
       if (incompletes > 0) {
-        this.currentBufferTarget.inlinedAllStylesheets = false;
+        this.events.inlinedAllStylesheets = false;
         this.#warnCSSOnce();
         handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Skipped', incompletes], undefined, FEATURE_NAMES.metrics, this.parent.ee);
       }
@@ -144,7 +135,7 @@ export class Recorder {
       /** wait for the evaluator to download/replace the incompletes' src code and then take a new snap */
       stylesheetEvaluator.fix().then(failedToFix => {
         if (failedToFix > 0) {
-          this.currentBufferTarget.inlinedAllStylesheets = false;
+          this.events.inlinedAllStylesheets = false;
           this.shouldFix = false;
         }
         handle(SUPPORTABILITY_METRIC_CHANNEL, [missingInlineSMTag + 'Failed', failedToFix], undefined, FEATURE_NAMES.metrics, this.parent.ee);
@@ -158,15 +149,12 @@ export class Recorder {
     if (!this.#fixing) this.store(event, isCheckout);
   }
 
-  /** Store a payload in the buffer (this.#events).  This should be the callback to the recording lib noticing a mutation */
+  /** Store a payload in the buffer (this.events).  This should be the callback to the recording lib noticing a mutation */
   store(event, isCheckout) {
-    if (!event) return;
-    if (!(this.parent instanceof AggregateBase) && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
-    if (this.parent.blocked) return;
-    if (this.parent.timeKeeper?.ready && !event.__newrelic) {
-      event.__newrelic = buildNRMetaNode(event.timestamp, this.parent.timeKeeper);
-      event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
-    }
+    if (!event || this.parent.blocked) return;
+
+    /** because we've waited until draining to process the buffered rrweb events, we can guarantee the timekeeper exists */
+    event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
     event.__serialized = stringify(event);
     const eventBytes = event.__serialized.length;
     /** The estimated size of the payload after compression */
@@ -181,26 +169,18 @@ export class Recorder {
     }
 
     // meta event
-    if (event.type === RRWEB_EVENT_TYPES.Meta) {
-      this.currentBufferTarget.hasMeta = true;
-    }
+    this.events.hasMeta ||= event.type === RRWEB_EVENT_TYPES.Meta;
     // snapshot event
-    if (event.type === RRWEB_EVENT_TYPES.FullSnapshot) {
-      this.currentBufferTarget.hasSnapshot = true;
-      this.hasSeenSnapshot = true;
-    }
-    this.currentBufferTarget.add(event);
+    this.events.hasSnapshot ||= this.hasSeenSnapshot ||= 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);
 
     // We are making an effort to try to keep payloads manageable for unloading.  If they reach the unload limit before their interval,
     // it will send immediately.  This often happens on the first snapshot, which can be significantly larger than the other payloads.
-    if ((event.type === RRWEB_EVENT_TYPES.FullSnapshot && this.currentBufferTarget.hasMeta || payloadSize > IDEAL_PAYLOAD_SIZE) && this.parent.mode === MODE.FULL) {
-      // if we've made it to the ideal size of ~64kb before the interval timer, we should send early.
-      if (this.parent instanceof AggregateBase) {
-        this.parent.agentRef.runtime.harvester.triggerHarvestFor(this.parent);
-      } else {
-        // we are still in "preload" and it triggered a "stop point".  Make a new set, which will get pointed at on next cycle
-        this.#preloaded.push(new RecorderEvents(this.shouldFix));
-      }
+    if ((this.events.hasSnapshot && this.events.hasMeta || payloadSize > IDEAL_PAYLOAD_SIZE) && this.parent.mode === MODE.FULL) {
+      // if we've made it to the ideal size of ~16kb before the interval timer, we should send early.
+      this.parent.agentRef.runtime.harvester.triggerHarvestFor(this.parent);
     }
   }
 
@@ -214,13 +194,13 @@ export class Recorder {
     }
   }
   clearTimestamps() {
-    this.currentBufferTarget.cycleTimestamp = undefined;
+    this.events.cycleTimestamp = undefined;
   }
 
   /** Estimate the payload size */
   getPayloadSize(newBytes = 0) {
     // the query param padding constant gives us some padding for the other metadata to be safely injected
-    return this.estimateCompression(this.currentBufferTarget.payloadBytesEstimation + newBytes) + QUERY_PARAM_PADDING;
+    return this.estimateCompression(this.events.payloadBytesEstimation + newBytes) + QUERY_PARAM_PADDING;
   }
 
   /** Extensive research has yielded about an 88% compression factor on these payloads.

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

@@ -4,7 +4,6 @@
  */
 import { gosNREUMOriginals } from '../../../common/window/nreum';
 import { canEnableSessionTracking } from '../../utils/feature-gates';
-import { originTime } from '../../../common/constants/runtime';
 export function hasReplayPrerequisite(agentInit) {
   return !!gosNREUMOriginals().o.MO &&
   // Session Replay cannot work without Mutation Observer
@@ -15,17 +14,6 @@ export function hasReplayPrerequisite(agentInit) {
 export function isPreloadAllowed(agentInit) {
   return agentInit?.session_replay.preload === true && hasReplayPrerequisite(agentInit);
 }
-export function buildNRMetaNode(timestamp, timeKeeper) {
-  const correctedTimestamp = timeKeeper.correctAbsoluteTimestamp(timestamp);
-  return {
-    originalTimestamp: timestamp,
-    correctedTimestamp,
-    timestampDiff: timestamp - correctedTimestamp,
-    originTime,
-    correctedOriginTime: timeKeeper.correctedOriginTime,
-    originTimeDiff: Math.floor(originTime - timeKeeper.correctedOriginTime)
-  };
-}
 export function customMasker(text, element) {
   try {
     if (typeof element?.type === 'string') {

package/dist/esm/features/utils/aggregate-base.js

@@ -34,8 +34,9 @@ export class AggregateBase extends FeatureBase {
     /** @type {Boolean} indicates if custom attributes are combined in each event payload for size estimation purposes. this is set to true in derived classes that need to evaluate custom attributes separately from the event payload */
     this.customAttributesAreSeparate = false;
     /** @type {Boolean} indicates if the feature can harvest early. This is set to false in derived classes that need to block early harvests, like ajax under certain conditions */
-    this.canHarvestEarly = true; // this is set to false in derived classes that need to block early harvests, like ajax under certain conditions
-
+    this.canHarvestEarly = true;
+    /** @type {Boolean} indicates if the feature is actively in a retry deferral period */
+    this.isRetrying = false;
     this.harvestOpts = {}; // features aggregate classes can define custom opts for when their harvest is called
 
     const agentEntityGuid = this.agentRef?.runtime?.appMetadata?.agents?.[0]?.entityGuid;
@@ -83,7 +84,7 @@ export class AggregateBase extends FeatureBase {
    * @returns void
    */
   decideEarlyHarvest() {
-    if (!this.canHarvestEarly) return;
+    if (!this.canHarvestEarly || this.blocked || this.isRetrying) return;
     const estimatedSize = this.events.byteSize() + (this.customAttributesAreSeparate ? this.agentRef.runtime.jsAttributesMetadata.bytes : 0);
     if (estimatedSize > IDEAL_PAYLOAD_SIZE) {
       this.agentRef.runtime.harvester.triggerHarvestFor(this);
@@ -172,8 +173,8 @@ export class AggregateBase extends FeatureBase {
    * @param {boolean=} result.retry - whether the harvest should be retried
    */
   postHarvestCleanup(result = {}) {
-    const harvestFailed = result.sent && result.retry;
-    if (harvestFailed) this.events.reloadSave(this.harvestOpts, result.targetApp?.entityGuid);
+    this.isRetrying = result.sent && result.retry;
+    if (this.isRetrying) this.events.reloadSave(this.harvestOpts, result.targetApp?.entityGuid);
     this.events.clearSave(this.harvestOpts, result.targetApp?.entityGuid);
   }
 

package/dist/esm/features/utils/event-buffer.js

@@ -38,10 +38,11 @@ export class EventBuffer {
   /**
    * Add feature-processed event to our buffer. If this event would cause our total raw size to exceed the set max payload size, it is dropped.
    * @param {any} event - any primitive type or object
+   * @param {number} [evaluatedSize] - the evalated size of the event, if already done so before storing in the event buffer
    * @returns {Boolean} true if successfully added; false otherwise
    */
-  add(event) {
-    const addSize = stringify(event)?.length || 0; // (estimate) # of bytes a directly stringified event it would take to send
+  add(event, evaluatedSize) {
+    const addSize = evaluatedSize || stringify(event)?.length || 0; // (estimate) # of bytes a directly stringified event it would take to send
     if (this.#rawBytes + addSize > this.maxPayloadSize) {
       const smTag = inject => "EventBuffer/".concat(inject, "/Dropped/Bytes");
       this.featureAgg?.reportSupportabilityMetric(smTag(this.featureAgg.featureName), addSize); // bytes dropped for this feature will aggregate with this metric tag

package/dist/types/common/harvest/harvester.d.ts

@@ -1,3 +1,18 @@
+/**
+  * Initiate a harvest call.
+  * @param {NetworkSendSpec} param0 Specification for sending data
+  * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
+  */
+export function send(agentRef: any, { endpoint, targetApp, payload, localOpts, submitMethod, cbFinished, raw, featureName }: {
+    endpoint: any;
+    targetApp: any;
+    payload: any;
+    localOpts?: {} | undefined;
+    submitMethod: any;
+    cbFinished: any;
+    raw: any;
+    featureName: any;
+}): boolean;
 export class Harvester {
     constructor(agentRef: any);
     initializedAggregates: any[];

package/dist/types/common/harvest/harvester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harvester.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvester.js"],"names":[],"mappings":"AAuBA;IAIE,2BAUC;IAZD,6BAA0B;IAGxB,cAAwB;IAW1B,wCASC;IAED;;;;;OAKG;IACH,iCAJW,MAAM,cACN,MAAM,GACJ,OAAO,CA+CnB;;CACF;8BAGY,OAAO,YAAY,EAAE,eAAe"}
+{"version":3,"file":"harvester.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvester.js"],"names":[],"mappings":"AA6GA;;;;IAII;AACJ;;;;;;;;;IAFc,OAAO,CA+FpB;AAxLD;IAIE,2BAUC;IAZD,6BAA0B;IAGxB,cAAwB;IAW1B,wCASC;IAED;;;;;OAKG;IACH,iCAJW,MAAM,cACN,MAAM,GACJ,OAAO,CA+CnB;;CACF;8BAGY,OAAO,YAAY,EAAE,eAAe"}

package/dist/types/features/session_replay/aggregate/index.d.ts

@@ -30,7 +30,6 @@ export class Aggregate extends AggregateBase {
         targetApp: undefined;
         payload: undefined;
     }[] | undefined;
-    getCorrectedTimestamp(node: any): any;
     /**
      * returns the timestamps for the earliest and latest nodes in the provided array, even if out of order
      * @param {Object[]} [nodes] - the nodes to evaluate

package/dist/types/features/session_replay/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAyBA;IACE,2BAAiC;IAIjC,sCAsFC;IAzFD,aAAe;IAKb,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,kBAA+C;IAG/C,kCAAqG;IAoEvG,0BAEC;IAED,0BAMC;IAED,qBAUC;IAED;;;;;OAKG;IACH,4BAJW,OAAO,iBACP,OAAO,GACL,IAAI,CAuDhB;IAED,2BASC;IAED;;;oBAuDC;IAED,sCAIC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GACN;QAAE,UAAU,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,GAAC,SAAS,CAAA;KAAE,CAUzE;IAED;;;;;;;;;;MAsEC;IAED,sCAKC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,+CASC;IAED,yCAIC;CACF;8BAtY6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAwBA;IACE,2BAAiC;IAIjC,sCAqFC;IAxFD,aAAe;IAKb,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,kBAA+C;IAG/C,kCAAqG;IAmEvG,0BAEC;IAED,0BAMC;IAED,qBAUC;IAED;;;;;OAKG;IACH,4BAJW,OAAO,iBACP,OAAO,GACL,IAAI,CAkDhB;IAED,2BASC;IAED;;;oBAyCC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GACN;QAAE,UAAU,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,GAAC,SAAS,CAAA;KAAE,CAUzE;IAED;;;;;;;;;;MAsEC;IAED,sCAKC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,+CASC;IAED,yCAIC;CACF;8BA3W6B,4BAA4B"}

package/dist/types/features/session_replay/shared/recorder-events.d.ts

@@ -15,7 +15,7 @@ export class RecorderEvents {
     hasError: boolean;
     /** Payload metadata -- Denotes whether all stylesheet elements were able to be inlined */
     inlinedAllStylesheets: boolean;
-    add(event: any): void;
+    add(event: any, evaluatedSize: any): void;
     get events(): any[];
     /** A value which increments with every new mutation node reported. Resets after a harvest is sent */
     get payloadBytesEstimation(): number;

package/dist/types/features/session_replay/shared/recorder-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder-events.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder-events.js"],"names":[],"mappings":"AAMA;IAiBE,+CAGC;IAjBD;;SAEK;IACL,uBAA2B;IAC3B;;;MAGE;IACF,qBAAmB;IACnB,4IAA4I;IAC5I,iBAAe;IACf,+HAA+H;IAC/H,kBAAgB;IAGd,0FAA0F;IAC1F,+BAAoD;IAGtD,sBAEC;IAED,oBAEC;IAED,qGAAqG;IACrG,qCAEC;;CACF"}
+{"version":3,"file":"recorder-events.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder-events.js"],"names":[],"mappings":"AAMA;IAiBE,+CAGC;IAjBD;;SAEK;IACL,uBAA2B;IAC3B;;;MAGE;IACF,qBAAmB;IACnB,4IAA4I;IAC5I,iBAAe;IACf,+HAA+H;IAC/H,kBAAgB;IAGd,0FAA0F;IAC1F,+BAAoD;IAGtD,0CAEC;IAED,oBAEC;IAED,qGAAqG;IACrG,qCAEC;;CACF"}

package/dist/types/features/session_replay/shared/recorder.d.ts

@@ -4,9 +4,11 @@ export class Recorder {
     parent: any;
     /** A flag that can be set to false by failing conversions to stop the fetching process */
     shouldFix: any;
-    /** The pointer to the current bucket holding rrweb events */
-    currentBufferTarget: RecorderEvents;
-    /** Only set to true once a snapshot node has been processed.  Used to block preload harvests from sending before we know we have a snapshot */
+    /** Each page mutation or event will be stored (raw) in this array. This array will be cleared on each harvest */
+    events: RecorderEvents;
+    /** Backlog used for a 2-part sliding window to guarantee a 15-30s buffer window */
+    backloggedEvents: RecorderEvents;
+    /** Only set to true once a snapshot node has been processed.  Used to block harvests from sending before we know we have a snapshot */
     hasSeenSnapshot: boolean;
     /** 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 */
     lastMeta: boolean;
@@ -14,15 +16,15 @@ export class Recorder {
     stopRecording: () => void;
     getEvents(): {
         events: any[];
-        payloadBytesEstimation: number;
         type: string;
         cycleTimestamp: number;
-        hasSnapshot: boolean;
-        hasMeta: boolean;
+        payloadBytesEstimation: number;
         hasError: boolean;
+        hasMeta: boolean;
+        hasSnapshot: boolean;
         inlinedAllStylesheets: boolean;
     };
-    /** Clears the buffer (this.#events), and resets all payload metadata properties */
+    /** Clears the buffer (this.events), and resets all payload metadata properties */
     clearBuffer(): void;
     /** Begin recording using configured recording lib */
     startRecording(): void;
@@ -33,7 +35,7 @@ export class Recorder {
      * @param {*} isCheckout - Flag indicating if the payload was triggered as a checkout
      */
     audit(event: any, isCheckout: any): void;
-    /** Store a payload in the buffer (this.#events).  This should be the callback to the recording lib noticing a mutation */
+    /** Store a payload in the buffer (this.events).  This should be the callback to the recording lib noticing a mutation */
     store(event: any, isCheckout: any): void;
     /** force the recording lib to take a full DOM snapshot.  This needs to occur in certain cases, like visibility changes */
     takeFullSnapshot(): void;

package/dist/types/features/session_replay/shared/recorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAmBA;IAYE,yBAiBC;IAhBC,sDAAsD;IACtD,YAAoB;IACpB,0FAA0F;IAC1F,eAAyE;IAKzE,6DAA6D;IAC7D,oCAAuC;IACvC,+IAA+I;IAC/I,yBAA4B;IAC5B,kIAAkI;IAClI,kBAAqB;IACrB,uIAAuI;IACvI,0BAA+E;IAGjF;;;;;;;;;MAmBC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBAiCC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,0HAA0H;IAC1H,yCA+CC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAjO8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAqBA;IAME,yBAkBC;IAjBC,sDAAsD;IACtD,YAAoB;IACpB,0FAA0F;IAC1F,eAAyE;IAEzE,iHAAiH;IACjH,uBAAgD;IAChD,mFAAmF;IACnF,iCAA0D;IAC1D,uIAAuI;IACvI,yBAA4B;IAC5B,kIAAkI;IAClI,kBAAqB;IACrB,uIAAuI;IACvI,0BAA+E;IAKjF;;;;;;;;;MAWC;IAED,kFAAkF;IAClF,oBAGC;IAED,qDAAqD;IACrD,uBAiCC;IAED;;;;;OAKG;IACH,aAHW,GAAC,cACD,GAAC,QAiCX;IAED,yHAAyH;IACzH,yCAgCC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BArM8B,mBAAmB"}

package/dist/types/features/session_replay/shared/utils.d.ts

@@ -1,12 +1,4 @@
 export function hasReplayPrerequisite(agentInit: any): boolean;
 export function isPreloadAllowed(agentInit: any): boolean;
-export function buildNRMetaNode(timestamp: any, timeKeeper: any): {
-    originalTimestamp: any;
-    correctedTimestamp: any;
-    timestampDiff: number;
-    originTime: number;
-    correctedOriginTime: any;
-    originTimeDiff: number;
-};
 export function customMasker(text: any, element: any): any;
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/features/session_replay/shared/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAQA,+DAIC;AAED,0DAEC;AAED;;;;;;;EAUC;AAED,2DAUC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAOA,+DAIC;AAED,0DAEC;AAED,2DAUC"}

package/dist/types/features/utils/aggregate-base.d.ts

@@ -10,6 +10,8 @@ export class AggregateBase extends FeatureBase {
     customAttributesAreSeparate: boolean;
     /** @type {Boolean} indicates if the feature can harvest early. This is set to false in derived classes that need to block early harvests, like ajax under certain conditions */
     canHarvestEarly: boolean;
+    /** @type {Boolean} indicates if the feature is actively in a retry deferral period */
+    isRetrying: boolean;
     harvestOpts: {};
     events: any;
     /**

package/dist/types/features/utils/aggregate-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAsBA;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EAyBhB;IArBC,iBAAwB;IAIxB,uOAAuO;IACvO,qCAAwC;IACxC,gLAAgL;IAChL,yBAA2B;IAE3B,gBAAqB;IA4BjB,YAAwJ;IAW9J;;;;OAIG;IACH,2BAOC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED;;OAEG;IACH,cAGC;IADC,6BAAmB;IAGrB,qCAEC;IAED;;;;;;OAMG;IACH,uDAJW,MAAM,GAAC,SAAS,SAyB1B;IAED;;;;;;;OAOG;IACH,4BALG;QAAwB,SAAS,GAAzB,MAAM,YAAC;KACf,QAQF;IAED;;;OAGG;IACH,6CAsBC;IAED;;;OAGG;IACH,2CAOC;IALC,gBAA6C;IAO/C;;;;OAIG;IACH,uCAHW,GAAC,UACD,GAAC,QAIX;;CACF;4BA7N2B,gBAAgB"}
+{"version":3,"file":"aggregate-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/aggregate-base.js"],"names":[],"mappings":"AAsBA;IACE;;;;OAIG;IACH,sBAHW,MAAM,eACN,MAAM,EA2BhB;IAvBC,iBAAwB;IAIxB,uOAAuO;IACvO,qCAAwC;IACxC,gLAAgL;IAChL,yBAA2B;IAC3B,sFAAsF;IACtF,oBAAuB;IAEvB,gBAAqB;IA4BjB,YAAwJ;IAW9J;;;;OAIG;IACH,2BAOC;IAED;;;;OAIG;IACH,yBAHW,MAAM,EAAE,gBAwBlB;IAED;;OAEG;IACH,cAGC;IADC,6BAAmB;IAGrB,qCAEC;IAED;;;;;;OAMG;IACH,uDAJW,MAAM,GAAC,SAAS,SAyB1B;IAED;;;;;;;OAOG;IACH,4BALG;QAAwB,SAAS,GAAzB,MAAM,YAAC;KACf,QAQF;IAED;;;OAGG;IACH,6CAsBC;IAED;;;OAGG;IACH,2CAOC;IALC,gBAA6C;IAO/C;;;;OAIG;IACH,uCAHW,GAAC,UACD,GAAC,QAIX;;CACF;4BA/N2B,gBAAgB"}

package/dist/types/features/utils/event-buffer.d.ts

@@ -15,9 +15,10 @@ export class EventBuffer {
     /**
      * Add feature-processed event to our buffer. If this event would cause our total raw size to exceed the set max payload size, it is dropped.
      * @param {any} event - any primitive type or object
+     * @param {number} [evaluatedSize] - the evalated size of the event, if already done so before storing in the event buffer
      * @returns {Boolean} true if successfully added; false otherwise
      */
-    add(event: any): boolean;
+    add(event: any, evaluatedSize?: number): boolean;
     /**
    * Merges events in the buffer that match the given criteria.
    * @param {Function} matcher - A function that takes an event and returns true if it should be merged.

package/dist/types/features/utils/event-buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-buffer.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/event-buffer.js"],"names":[],"mappings":"AAOA;IAME;;;;OAIG;IACH,kDAFW,MAAM,EAKhB;IAFC,uBAAoC;IACpC,+BAA4B;IAG9B,qBAEC;IAED,mBAEC;IAED,aAEC;IAED,mBAEC;IAED,+CAEC;IAED;;;;OAIG;IACH,WAHW,GAAG,WAeb;IAED;;;;;KAKC;IACD,+BAHS,MAAM,GACJ,OAAO,CAWjB;IAED;;;;;;;OAOG;IACH,aALG;QAAsB,eAAe;QACf,YAAY;QACZ,gBAAgB;KACtC,GAAU,IAAI,CAWhB;IAED;;OAEG;IACH,aAGC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,mBAKC;;CACF"}
+{"version":3,"file":"event-buffer.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/event-buffer.js"],"names":[],"mappings":"AAOA;IAME;;;;OAIG;IACH,kDAFW,MAAM,EAKhB;IAFC,uBAAoC;IACpC,+BAA4B;IAG9B,qBAEC;IAED,mBAEC;IAED,aAEC;IAED,mBAEC;IAED,+CAEC;IAED;;;;;OAKG;IACH,WAJW,GAAG,kBACH,MAAM,WAehB;IAED;;;;;KAKC;IACD,+BAHS,MAAM,GACJ,OAAO,CAWjB;IAED;;;;;;;OAOG;IACH,aALG;QAAsB,eAAe;QACf,YAAY;QACZ,gBAAgB;KACtC,GAAU,IAAI,CAWhB;IAED;;OAEG;IACH,aAGC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,mBAKC;;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.296.0",
+  "version": "1.297.0-rc.1",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -295,4 +295,4 @@
     "README.md",
     "CHANGELOG.md"
   ]
-}
+}

package/src/common/harvest/harvester.js

@@ -112,7 +112,7 @@ const warnings = {}
   * @param {NetworkSendSpec} param0 Specification for sending data
   * @returns {boolean} True if a network call was made. Note that this does not mean or guarantee that it was successful.
   */
-function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName }) {
+export function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitMethod, cbFinished, raw, featureName }) {
   if (!agentRef.info.errorBeacon) return false
 
   let { body, qs } = cleanPayload(payload)
@@ -218,7 +218,7 @@ function send (agentRef, { endpoint, targetApp, payload, localOpts = {}, submitM
 function cleanPayload (payload = {}) {
   const clean = (input) => {
     if ((typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) || Array.isArray(input)) return input
-    if (typeof input === 'string') return input.length > 0 ? input : null
+    if (typeof input === 'string') return input
     return Object.entries(input || {}).reduce((accumulator, [key, value]) => {
       if ((typeof value === 'number') ||
           (typeof value === 'string' && value.length > 0) ||

package/src/features/session_replay/aggregate/index.js

@@ -18,7 +18,6 @@ import { MODE, SESSION_EVENTS, SESSION_EVENT_TYPES } from '../../../common/sessi
 import { stringify } from '../../../common/util/stringify'
 import { stylesheetEvaluator } from '../shared/stylesheet-evaluator'
 import { now } from '../../../common/timing/now'
-import { buildNRMetaNode } from '../shared/utils'
 import { MAX_PAYLOAD_SIZE } from '../../../common/constants/agent-constants'
 import { cleanURL } from '../../../common/url/clean-url'
 import { canEnableSessionTracking } from '../../utils/feature-gates'
@@ -94,8 +93,7 @@ export class Aggregate extends AggregateBase {
         }
         return
       }
-      this.drain()
-      this.initializeRecording(srMode)
+      this.initializeRecording(srMode).then(() => { this.drain() })
     }).then(() => {
       if (this.mode === MODE.OFF) {
         this.recorder?.stopRecording() // stop any conservative preload recording launched by instrument
@@ -121,7 +119,7 @@ export class Aggregate extends AggregateBase {
   }
 
   handleError (e) {
-    if (this.recorder) this.recorder.currentBufferTarget.hasError = true
+    if (this.recorder) this.recorder.events.hasError = true
     // run once
     if (this.mode === MODE.ERROR && globalScope?.document.visibilityState === 'visible') {
       this.switchToFull()
@@ -171,10 +169,10 @@ export class Aggregate extends AggregateBase {
 
     if (!this.recorder) {
       try {
-      // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
+        // Do not change the webpackChunkName or it will break the webpack nrba-chunking plugin
         const { Recorder } = (await import(/* webpackChunkName: "recorder" */'../shared/recorder'))
         this.recorder = new Recorder(this)
-        this.recorder.currentBufferTarget.hasError = this.errorNoticed
+        this.recorder.events.hasError = this.errorNoticed
       } catch (err) {
         return this.abort(ABORT_REASONS.IMPORT)
       }
@@ -189,11 +187,6 @@ export class Aggregate extends AggregateBase {
     // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
     // The makeHarvestPayload should ensure that no payload is returned if we're not in FULL mode...
 
-    // If theres preloaded events and we are in full mode, just harvest immediately to clear up space and for consistency
-    if (this.mode === MODE.FULL && this.recorder?.getEvents().type === 'preloaded') {
-      this.prepUtils().then(() => this.agentRef.runtime.harvester.triggerHarvestFor(this))
-    }
-
     await this.prepUtils()
 
     if (!this.agentRef.runtime.isRecording) this.recorder.startRecording()
@@ -231,24 +224,10 @@ export class Aggregate extends AggregateBase {
 
     let len = 0
     if (!!this.gzipper && !!this.u8) {
-      payload.body = this.gzipper(this.u8(`[${payload.body.map(({ __serialized, ...e }) => {
-        if (e.__newrelic && __serialized) return __serialized
-        const output = { ...e }
-        if (!output.__newrelic) {
-          output.__newrelic = buildNRMetaNode(e.timestamp, this.timeKeeper)
-          output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(e.timestamp)
-        }
-        return stringify(output)
-      }).join(',')}]`))
+      payload.body = this.gzipper(this.u8(`[${payload.body.map(({ __serialized }) => (__serialized)).join(',')}]`))
       len = payload.body.length
     } else {
-      payload.body = payload.body.map(({ __serialized, ...node }) => {
-        if (node.__newrelic) return node
-        const output = { ...node }
-        output.__newrelic = buildNRMetaNode(node.timestamp, this.timeKeeper)
-        output.timestamp = this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
-        return output
-      })
+      for (let idx in payload.body) delete payload.body[idx].__serialized
       len = stringify(payload.body).length
     }
 
@@ -269,12 +248,6 @@ export class Aggregate extends AggregateBase {
     return [payloadOutput]
   }
 
-  getCorrectedTimestamp (node) {
-    if (!node?.timestamp) return
-    if (node.__newrelic) return node.timestamp
-    return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
-  }
-
   /**
    * returns the timestamps for the earliest and latest nodes in the provided array, even if out of order
    * @param {Object[]} [nodes] - the nodes to evaluate
@@ -318,8 +291,8 @@ export class Aggregate extends AggregateBase {
 
     const { firstEvent, lastEvent } = this.getFirstAndLastNodes(events)
     // from rrweb node || from when the harvest cycle started
-    const firstTimestamp = this.getCorrectedTimestamp(firstEvent) || Math.floor(this.timeKeeper.correctAbsoluteTimestamp(recorderEvents.cycleTimestamp))
-    const lastTimestamp = this.getCorrectedTimestamp(lastEvent) || Math.floor(this.timeKeeper.correctRelativeTimestamp(relativeNow))
+    const firstTimestamp = firstEvent?.timestamp || Math.floor(this.timeKeeper.correctAbsoluteTimestamp(recorderEvents.cycleTimestamp))
+    const lastTimestamp = lastEvent?.timestamp || Math.floor(this.timeKeeper.correctRelativeTimestamp(relativeNow))
 
     const agentMetadata = agentRuntime.appMetadata?.agents?.[0] || {}
 

package/src/features/session_replay/instrument/index.js

@@ -78,7 +78,7 @@ export class Instrument extends InstrumentBase {
 
       // If startReplay() has been used by this point, we must record in full mode regardless of session preload:
       // Note: recorder starts here with w/e the mode is at this time, but this may be changed later (see #apiStartOrRestartReplay else-case)
-      this.recorder ??= new Recorder({ mode: this.#mode, agentIdentifier: this.agentIdentifier, trigger, ee: this.ee, agentRef: this.#agentRef })
+      this.recorder ??= new Recorder({ ...this, mode: this.#mode, agentRef: this.#agentRef, trigger, timeKeeper: this.#agentRef.runtime.timeKeeper }) // if TK exists due to deferred state, pass it
       this.recorder.startRecording()
       this.abortHandler = this.recorder.stopRecording
     } catch (err) {

package/src/features/session_replay/shared/recorder-events.js

@@ -26,8 +26,8 @@ export class RecorderEvents {
     this.inlinedAllStylesheets = shouldInlineStylesheets
   }
 
-  add (event) {
-    this.#events.add(event)
+  add (event, evaluatedSize) {
+    this.#events.add(event, evaluatedSize)
   }
 
   get events () {