@newrelic/browser-agent 1.296.0-rc.3 → 1.296.0-rc.5

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/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/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/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-rc.3",
+  "version": "1.296.0-rc.5",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",

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

@@ -10,7 +10,7 @@ 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 { FEATURE_NAME, SR_EVENT_EMITTER_TYPES } from '../constants'
 import { setupRecordReplayAPI } from '../../../loaders/api/recordReplay'
 import { setupPauseReplayAPI } from '../../../loaders/api/pauseReplay'
 
@@ -69,7 +69,7 @@ export class Instrument extends InstrumentBase {
   /**
    * This func is use for early pre-load recording prior to replay feature (agg) being loaded onto the page. It should only setup once, including if already called and in-progress.
    */
-  async #preloadStartRecording (trigger) {
+  async #preloadStartRecording () {
     if (this.#alreadyStarted) return
     this.#alreadyStarted = true
 
@@ -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, timeKeeper: this.#agentRef.runtime.timeKeeper }) // if TK exists due to deferred state, pass it
       this.recorder.startRecording()
       this.abortHandler = this.recorder.stopRecording
     } catch (err) {
@@ -95,7 +95,7 @@ export class Instrument extends InstrumentBase {
       if (this.featAggregate.mode !== MODE.FULL) this.featAggregate.initializeRecording(MODE.FULL, true)
     } else { // pre-load
       this.#mode = MODE.FULL
-      this.#preloadStartRecording(TRIGGERS.API)
+      this.#preloadStartRecording()
       // There's a race here wherein either:
       // a. Recorder has not been initialized, and we've set the enforced mode, so we're good, or;
       // b. Record has been initialized, possibly with the "wrong" mode, so we have to correct that + restart.

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 () {