@newrelic/browser-agent 1.256.1 → 1.257.0

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

@@ -9,9 +9,10 @@
  * It is not production ready, and is not intended to be imported or implemented in any build of the browser agent until
  * functionality is validated and a full user experience is curated.
  */
+import { handle } from '../../../common/event-emitter/handle';
 import { DEFAULT_KEY, MODE, PREFIX } from '../../../common/session/constants';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME } from '../constants';
+import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES } from '../constants';
 import { isPreloadAllowed } from '../shared/utils';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
@@ -19,19 +20,28 @@ export class Instrument extends InstrumentBase {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, FEATURE_NAME, auto);
     let session;
+    this.replayRunning = false;
     try {
       session = JSON.parse(localStorage.getItem("".concat(PREFIX, "_").concat(DEFAULT_KEY)));
     } catch (err) {}
     if (this.#canPreloadRecorder(session)) {
-      /** If this is preloaded, set up a buffer, if not, later when sampling we will set up a .on for live events */
-      this.ee.on('err', e => {
-        this.errorNoticed = true;
-        if (this.featAggregate) this.featAggregate.handleError();
-      });
       this.#startRecording(session?.sessionReplayMode);
     } else {
       this.importAggregator();
     }
+
+    /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
+    this.ee.on('err', e => {
+      if (this.replayRunning) {
+        this.errorNoticed = true;
+        handle(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee);
+      }
+    });
+
+    /** Emitted by the recorder when it starts capturing data, used to determine if we should pass errors on to the agg */
+    this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, isRunning => {
+      this.replayRunning = isRunning;
+    });
   }
 
   // At this point wherein session state exists already but we haven't init SessionEntity aka verify timers.

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

@@ -97,11 +97,10 @@ export class Recorder {
       collectFonts: collect_fonts,
       checkoutEveryNms: CHECKOUT_MS[this.parent.mode]
     });
-    this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
     this.stopRecording = () => {
       this.recording = false;
       this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode]);
-      stop();
+      stop?.();
     };
   }
 
@@ -144,6 +143,10 @@ export class Recorder {
     if (!event) return;
     if (!this.parent.scheduler && this.#preloaded.length) this.currentBufferTarget = this.#preloaded[this.#preloaded.length - 1];else this.currentBufferTarget = this.#events;
     if (this.parent.blocked) return;
+    if (!this.notified) {
+      this.parent.ee.emit(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
+      this.notified = true;
+    }
     if (this.parent.timeKeeper?.ready && !event.__newrelic) {
       event.__newrelic = buildNRMetaNode(event.timestamp, this.parent.timeKeeper);
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
@@ -174,7 +177,7 @@ export class Recorder {
 
     // 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 (payloadSize > IDEAL_PAYLOAD_SIZE && this.parent.mode !== MODE.ERROR) {
+    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.scheduler) {
         this.parent.scheduler.runHarvest();

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

@@ -1,10 +1,12 @@
 import { getConfigurationValue, originals } from '../../../common/config/config';
 import { isBrowserScope } from '../../../common/constants/runtime';
-export const enableSessionTracking = agentId => isBrowserScope && getConfigurationValue(agentId, 'privacy.cookies_enabled') === true;
+export function enableSessionTracking(agentId) {
+  return isBrowserScope && getConfigurationValue(agentId, 'privacy.cookies_enabled') === true;
+}
 function hasReplayPrerequisite(agentId) {
-  return originals.MO &&
+  return !!originals.MO &&
   // Session Replay cannot work without Mutation Observer
-  enableSessionTracking &&
+  enableSessionTracking(agentId) &&
   // requires session tracking to be running (hence "session" replay...)
   getConfigurationValue(agentId, 'session_trace.enabled') === true; // Session Replay as of now is tightly coupled with Session Trace in the UI
 }

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

@@ -82,7 +82,7 @@ export class Aggregate extends AggregateBase {
       if (!firstIxnStartTime) firstIxnStartTime = Math.floor(interaction.start);
     }
     const payload = "bel.7;".concat(serializedIxnList.join(';'));
-    if (options.retry) this.interactionsAwaitingRetry.push(...this.interactionsToHarvest);
+    if (options.retry) this.interactionsAwaitingRetry = this.interactionsToHarvest;
     this.interactionsToHarvest = [];
     return {
       body: {
@@ -93,8 +93,8 @@ export class Aggregate extends AggregateBase {
   onHarvestFinished(result) {
     if (result.sent && result.retry && this.interactionsAwaitingRetry.length > 0) {
       this.interactionsToHarvest = [...this.interactionsAwaitingRetry, ...this.interactionsToHarvest];
-      this.interactionsAwaitingRetry = [];
     }
+    this.interactionsAwaitingRetry = [];
   }
   startUIInteraction(eventName, startedAt, sourceElem) {
     // this is throttled by instrumentation so that it isn't excessively called

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

@@ -12,6 +12,7 @@ import { warn } from '../../common/util/console';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 import { getConfigurationValue } from '../../common/config/config';
 import { canImportReplayAgg, enableSessionTracking } from '../session_replay/shared/utils';
+import { single } from '../../common/util/invoke';
 
 /**
  * Base class for instrumenting a feature.
@@ -50,7 +51,15 @@ export class InstrumentBase extends FeatureBase {
     /** used in conjunction with newrelic.start() to defer harvesting in features */
     if (getConfigurationValue(this.agentIdentifier, "".concat(this.featureName, ".autoStart")) === false) this.auto = false;
     /** if the feature requires opt-in (!auto-start), it will get registered once the api has been called */
-    if (this.auto) registerDrain(agentIdentifier, featureName);
+    if (this.auto) registerDrain(agentIdentifier, featureName);else {
+      this.ee.on("".concat(this.featureName, "-opt-in"), single(() => {
+        // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
+        // called by the api in that cycle
+        registerDrain(this.agentIdentifier, this.featureName);
+        this.auto = true;
+        this.importAggregator();
+      }));
+    }
   }
 
   /**
@@ -61,19 +70,7 @@ export class InstrumentBase extends FeatureBase {
    */
   importAggregator() {
     let argsObjFromInstrument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    if (this.featAggregate) return;
-    if (!this.auto) {
-      // this feature requires an opt in...
-      // wait for API to be called
-      this.ee.on("".concat(this.featureName, "-opt-in"), () => {
-        // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
-        // called by the api in that cycle
-        registerDrain(this.agentIdentifier, this.featureName);
-        this.auto = true;
-        this.importAggregator();
-      });
-      return;
-    }
+    if (this.featAggregate || !this.auto) return;
     let loadedSuccessfully;
     this.onAggregateImported = new Promise(resolve => {
       loadedSuccessfully = resolve;

package/dist/esm/features/utils/nr1-debugger.js

@@ -0,0 +1,21 @@
+import { gosCDN } from '../../common/window/nreum';
+const debugId = 1;
+const newrelic = gosCDN();
+export function debugNR1(agentIdentifier, location, event) {
+  let otherprops = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  let debugName = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'SR';
+  const api = agentIdentifier ? newrelic.initializedAgents[agentIdentifier].api.addPageAction : newrelic.addPageAction;
+  let url;
+  try {
+    const locURL = new URL(window.location);
+    url = locURL.pathname;
+  } catch (err) {}
+  api(debugName, {
+    debugId,
+    url,
+    location,
+    event,
+    now: performance.now(),
+    ...otherprops
+  });
+}

package/dist/esm/loaders/agent.js

@@ -21,6 +21,10 @@ import { globalScope } from '../common/constants/runtime';
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
 export class Agent extends AgentBase {
+  /**
+   * @param {Object} options Options to initialize agent with
+   * @param {string} [agentIdentifier] Optional identifier of agent
+   */
   constructor(options, agentIdentifier) {
     super(agentIdentifier);
     if (!globalScope) {

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

@@ -34,7 +34,7 @@ export class Harvest extends SharedContext {
      * value should not be relied upon because network calls will be made asynchronously.
      */
     _send({ endpoint, payload, opts, submitMethod, cbFinished, customUrl, raw, includeBaseParams }: NetworkSendSpec): boolean;
-    baseQueryString(qs: any): string;
+    baseQueryString(qs: any, endpoint: any): string;
     /**
      * Calls and accumulates data from registered harvesting functions based on
      * the endpoint being harvested.

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

@@ -1 +1 @@
-{"version":3,"file":"harvest.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest.js"],"names":[],"mappings":"AAsBA;;;;;;GAMG;AACH;IAII,0BAA2H;IAC3H,uBAAoD;IAEpD,YAAiB;IAGnB;;;;;OAKG;IACH,aAFW,eAAe,WAWzB;IAED;;;OAGG;IACH,YAFW,eAAe,WAMzB;IAED;;;OAGG;IACH,wBAFW,eAAe,WAMzB;IAED;;;;;;OAMG;IACH,gGAJW,eAAe,GACb,OAAO,CAsFnB;IAGD,iCAoBC;IAED;;;;;;;OAOG;IACH,wBALW,yBAAyB,WACzB,6BAA6B,GAE3B,cAAc,CA2B1B;IAED;;;;;;;OAOG;IACH,uBAHW,cAAc,GACZ,cAAc,CAuB1B;IAED;;;;;OAKG;IACH,aAHW,yBAAyB,YACzB,sBAAsB,QAQhC;CACF;8BAvPY,OAAO,YAAY,EAAE,eAAe;wCACpC,OAAO,YAAY,EAAE,yBAAyB;6BAC9C,OAAO,YAAY,EAAE,cAAc;qCACnC,OAAO,YAAY,EAAE,sBAAsB;4CAC3C,OAAO,YAAY,EAAE,6BAA6B;8BAbjC,2BAA2B;2BAF9B,mBAAmB"}
+{"version":3,"file":"harvest.d.ts","sourceRoot":"","sources":["../../../../src/common/harvest/harvest.js"],"names":[],"mappings":"AAsBA;;;;;;GAMG;AACH;IAII,0BAA2H;IAC3H,uBAAoD;IAEpD,YAAiB;IAGnB;;;;;OAKG;IACH,aAFW,eAAe,WAWzB;IAED;;;OAGG;IACH,YAFW,eAAe,WAMzB;IAED;;;OAGG;IACH,wBAFW,eAAe,WAMzB;IAED;;;;;;OAMG;IACH,gGAJW,eAAe,GACb,OAAO,CAsFnB;IAGD,gDAsBC;IAED;;;;;;;OAOG;IACH,wBALW,yBAAyB,WACzB,6BAA6B,GAE3B,cAAc,CA2B1B;IAED;;;;;;;OAOG;IACH,uBAHW,cAAc,GACZ,cAAc,CAuB1B;IAED;;;;;OAKG;IACH,aAHW,yBAAyB,YACzB,sBAAsB,QAQhC;CACF;8BAzPY,OAAO,YAAY,EAAE,eAAe;wCACpC,OAAO,YAAY,EAAE,yBAAyB;6BAC9C,OAAO,YAAY,EAAE,cAAc;qCACnC,OAAO,YAAY,EAAE,sBAAsB;4CAC3C,OAAO,YAAY,EAAE,6BAA6B;8BAbjC,2BAA2B;2BAF9B,mBAAmB"}

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

@@ -10,7 +10,6 @@ export class Aggregate extends AggregateBase {
     bufferedErrorsUnderSpa: {};
     currentBody: {} | null | undefined;
     errorOnPage: boolean;
-    replayAborted: boolean;
     onHarvestStarted(options: any): {
         body: {} | null;
         qs: {};

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAmCC;IAhCC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IACxB,uBAA0B;IA4B5B;;;MA2BC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FAsFC;IA4BD,yDA6BC;IAED,qFAOC;;CACF;wBAhRY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAgCC;IA7BC,kBAAuB;IACvB,eAAoB;IACpB,qBAA0B;IAC1B,2BAAgC;IAChC,mCAA4B;IAC5B,qBAAwB;IA0B1B;;;MAuBC;IAED,qCAWC;IAED,8BAEC;IAED,oEAMC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4FAsFC;IA4BD,yDA6BC;IAED,qFAOC;;CAwBF;wBAhSY,OAAO,0BAA0B,EAAE,SAAS;8BAN3B,4BAA4B"}

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

@@ -15,7 +15,6 @@ export class Aggregate extends AggregateBase {
     /** set at BCS response, stored in runtime */
     timeKeeper: any;
     recorder: any;
-    preloaded: boolean;
     errorNoticed: any;
     scheduler: HarvestScheduler;
     handleError(e: any): void;

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":"AAgCA;IACE,2BAAiC;IAIjC,8DAsGC;IAzGD,aAAe;IAKb,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,mBAAgC;IAChC,kBAA+C;IA4B/C,4BAKQ;IAmDV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA8DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAoEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BAxY6B,4BAA4B;iCAHzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/aggregate/index.js"],"names":[],"mappings":"AAgCA;IACE,2BAAiC;IAIjC,8DAiHC;IApHD,aAAe;IAKb,8GAA8G;IAC9G,wBAAgH;IAChH,iFAAiF;IACjF,qBAAwB;IAGxB,2CAA2C;IAC3C,sDAAwB;IACxB,6CAA6C;IAC7C,gDAAmB;IAEnB,0BAA0B;IAC1B,kBAAqB;IACrB,6CAA6C;IAC7C,gBAA2B;IAE3B,cAA8B;IAC9B,kBAA+C;IAoC/C,4BAKQ;IAuDV,0BAMC;IAED,qBAWC;IAED;;;;;;;OAOG;IACH,iCALW,OAAO,cACP,OAAO,iBACP,OAAO,GACL,IAAI,CA6DhB;IAED,2BASC;IAED;;;;;;;;;;;;oBAiDC;IAED,sCAIC;IAED;;;;;;;;;;MAoEC;IAED,qCAOC;IAED;;;;OAIG;IACH,mCAKC;IAED,yDAAyD;IACzD,yBAUC;IAED,yCAGC;CACF;8BAlZ6B,4BAA4B;iCAHzB,2CAA2C"}

package/dist/types/features/session_replay/constants.d.ts

@@ -3,6 +3,7 @@ export namespace SR_EVENT_EMITTER_TYPES {
     let RECORD: string;
     let PAUSE: string;
     let REPLAY_RUNNING: string;
+    let ERROR_DURING_REPLAY: string;
 }
 export const AVG_COMPRESSION: 0.12;
 export namespace RRWEB_EVENT_TYPES {

package/dist/types/features/session_replay/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_replay/constants.js"],"names":[],"mappings":"AAGA,kCAAuD;;;;;;AAQvD,mCAAmC;;;;;;;;;AASnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AACvC,2GAA2G;AAC3G;;EAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtF,0CAA0C;AAC1C,uCAAuC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/features/session_replay/constants.js"],"names":[],"mappings":"AAGA,kCAAuD;;;;;;;AASvD,mCAAmC;;;;;;;;;AASnC,uCAAuC;AACvC,uCAAuC;AACvC,iCAAiC;AACjC,uCAAuC;AACvC,2GAA2G;AAC3G;;EAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtF,0CAA0C;AAC1C,uCAAuC"}

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

@@ -1,6 +1,7 @@
 export class Instrument extends InstrumentBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any, auto?: boolean);
+    replayRunning: boolean;
     errorNoticed: boolean;
     recorder: import("../shared/recorder").Recorder | undefined;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mEAiBC;IAPK,sBAAwB;IAwB5B,4DAA0F;;CAK7F;+BA7C8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/instrument/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,mEA0BC;IAvBC,uBAA0B;IActB,sBAAwB;IA0B5B,4DAA0F;;CAK7F;+BAtD8B,6BAA6B"}

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

@@ -37,6 +37,7 @@ export class Recorder {
     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(event: any, isCheckout: any): void;
+    notified: boolean | undefined;
     /** force the recording lib to take a full DOM snapshot.  This needs to occur in certain cases, like visibility changes */
     takeFullSnapshot(): void;
     clearTimestamps(): 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":"AAYA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,oEAAoE;IACpE,6BAAqH;IACrH,0FAA0F;IAC1F,eAA6C;IAC7C,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;MAYC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBAiCC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCAgDC;IAED,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BAjN8B,mBAAmB"}
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/recorder.js"],"names":[],"mappings":"AAYA;IAUE,yBAkBC;IAdC,iEAAiE;IACjE,mBAAsB;IACtB,6DAA6D;IAC7D,oCAAuC;IACvC,kIAAkI;IAClI,kBAAqB;IACrB,sDAAsD;IACtD,YAAoB;IACpB,oEAAoE;IACpE,6BAAqH;IACrH,0FAA0F;IAC1F,eAA6C;IAC7C,uIAAuI;IACvI,0BAAyE;IAG3E;;;;;;;;;MAYC;IAED,mFAAmF;IACnF,oBAKC;IAED,qDAAqD;IACrD,uBA+BC;IAED;;;;;OAKG;IACH,yCA0BC;IAED,0HAA0H;IAC1H,yCAqDC;IA3CG,8BAAoB;IA6CxB,0HAA0H;IAC1H,yBAOC;IAED,wBAEC;IAED,gCAAgC;IAChC,uCAGC;IAED;;;SAGK;IACL,oCAGC;;CACF;+BApN8B,mBAAmB"}

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

@@ -1,4 +1,5 @@
-export function isPreloadAllowed(agentId: any): any;
+export function enableSessionTracking(agentId: any): boolean;
+export function isPreloadAllowed(agentId: any): boolean;
 export function canImportReplayAgg(agentId: any, sessionMgr: any): boolean;
 export function buildNRMetaNode(timestamp: any, timeKeeper: any): {
     originalTimestamp: any;
@@ -8,5 +9,4 @@ export function buildNRMetaNode(timestamp: any, timeKeeper: any): {
     timeKeeperCorrectedOriginTime: any;
     timeKeeperDiff: number;
 };
-export function enableSessionTracking(agentId: any): boolean;
 //# 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":"AAWA,oDAEC;AAED,2EAGC;AAED;;;;;;;EAUC;AA3BM,6DAA+H"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_replay/shared/utils.js"],"names":[],"mappings":"AAGA,6DAEC;AAQD,wDAEC;AAED,2EAGC;AAED;;;;;;;EAUC"}

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

@@ -1 +1 @@
-{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6BAPW,MAAM,cACN,OAAO,mCAAmC,EAAE,UAAU,eACtD,MAAM,8BA4BhB;IArBC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,kCAAoC;IAQtC;;;;;OAKG;IACH,mEA6DC;;CAYF;4BA9H2B,gBAAgB"}
+{"version":3,"file":"instrument-base.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/instrument-base.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6BAPW,MAAM,cACN,OAAO,mCAAmC,EAAE,UAAU,eACtD,MAAM,8BAqChB;IA9BC,cAAgB;IAEhB,8IAA8I;IAC9I,cADW,WAAW,SAAS,CACF;IAE7B;;;MAGE;IACF,eAHU,OAAO,kBAAkB,EAAE,aAAa,CAGpB;IAE9B;;;MAGE;IACF,kCAAoC;IAiBtC;;;;;OAKG;IACH,mEAgDC;;CAYF;4BA3H2B,gBAAgB"}

package/dist/types/features/utils/nr1-debugger.d.ts

@@ -0,0 +1,2 @@
+export function debugNR1(agentIdentifier: any, location: any, event: any, otherprops?: {}, debugName?: string): void;
+//# sourceMappingURL=nr1-debugger.d.ts.map

package/dist/types/features/utils/nr1-debugger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nr1-debugger.d.ts","sourceRoot":"","sources":["../../../../src/features/utils/nr1-debugger.js"],"names":[],"mappings":"AAIA,qHAiBC"}

package/dist/types/loaders/agent.d.ts

@@ -3,7 +3,11 @@
  * sensitive to network load, this may result in smaller builds with slightly lower performance impact.
  */
 export class Agent extends AgentBase {
-    constructor(options: any, agentIdentifier: any);
+    /**
+     * @param {Object} options Options to initialize agent with
+     * @param {string} [agentIdentifier] Optional identifier of agent
+     */
+    constructor(options: Object, agentIdentifier?: string | undefined);
     sharedAggregator: Aggregator | undefined;
     features: {} | undefined;
     desiredFeatures: Set<any> | undefined;

package/dist/types/loaders/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH;IACE,gDAwBC;IAdC,yCAAiF;IACjF,yBAAkB;IAGlB,sCAAsD;IAMtD,uCAA6G;IAM/G;;;;;MAOC;IAED,yBAiCC;CACF;0BAxFyB,cAAc;2BAQb,gCAAgC"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/loaders/agent.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH;IACE;;;OAGG;IACH,qBAHW,MAAM,wCA2BhB;IAdC,yCAAiF;IACjF,yBAAkB;IAGlB,sCAAsD;IAMtD,uCAA6G;IAM/G;;;;;MAOC;IAED,yBAiCC;CACF;0BA5FyB,cAAc;2BAQb,gCAAgC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.256.1",
+  "version": "1.257.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",

package/src/common/drain/__mocks__/drain.js

@@ -0,0 +1,2 @@
+export const drain = jest.fn()
+export const registerDrain = jest.fn()

package/src/common/harvest/harvest.js

@@ -103,7 +103,7 @@ export class Harvest extends SharedContext {
     if (customUrl) url = customUrl
     if (raw) url = `${protocol}://${perceviedBeacon}/${endpoint}`
 
-    const baseParams = !raw && includeBaseParams ? this.baseQueryString(qs) : ''
+    const baseParams = !raw && includeBaseParams ? this.baseQueryString(qs, endpoint) : ''
     let payloadParams = encodeObj(qs, agentRuntime.maxBytes)
     if (!submitMethod) {
       submitMethod = submitData.getSubmitMethod({ isFinalHarvest: opts.unload })
@@ -167,14 +167,15 @@ export class Harvest extends SharedContext {
   }
 
   // The stuff that gets sent every time.
-  baseQueryString (qs) {
+  baseQueryString (qs, endpoint) {
     const runtime = getRuntime(this.sharedContext.agentIdentifier)
     const info = getInfo(this.sharedContext.agentIdentifier)
 
     const location = cleanURL(getLocation())
     const ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location
+    const hr = runtime?.session?.state.sessionReplayMode === 1 && endpoint !== 'jserrors'
 
-    return ([
+    const qps = [
       'a=' + info.applicationID,
       encodeParam('sa', (info.sa ? '' + info.sa : '')),
       encodeParam('v', VERSION),
@@ -184,9 +185,10 @@ export class Harvest extends SharedContext {
       '&ck=0', // ck param DEPRECATED - still expected by backend
       '&s=' + (runtime.session?.state.value || '0'), // the 0 id encaps all untrackable and default traffic
       encodeParam('ref', ref),
-      encodeParam('ptid', (runtime.ptid ? '' + runtime.ptid : '')),
-      encodeParam('hr', (runtime?.session?.state.sessionReplayMode === 1 ? '1' : '0'), qs) // hasReplay
-    ].join(''))
+      encodeParam('ptid', (runtime.ptid ? '' + runtime.ptid : ''))
+    ]
+    if (hr) qps.push(encodeParam('hr', '1', qs))
+    return qps.join('')
   }
 
   /**

package/src/common/window/__mocks__/load.js

@@ -0,0 +1,3 @@
+export const checkState = jest.fn()
+export const onWindowLoad = jest.fn()
+export const onDOMContentLoaded = jest.fn()

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

@@ -38,13 +38,10 @@ export class Aggregate extends AggregateBase {
     this.bufferedErrorsUnderSpa = {}
     this.currentBody = undefined
     this.errorOnPage = false
-    this.replayAborted = false
 
     // this will need to change to match whatever ee we use in the instrument
     this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved))
 
-    this.ee.on('REPLAY_ABORTED', () => { this.replayAborted = true })
-
     register('err', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('softNavFlush', (interactionId, wasFinished, softNavAttrs) =>
@@ -82,11 +79,7 @@ export class Aggregate extends AggregateBase {
     }
 
     if (body && body.err && body.err.length) {
-      if (this.replayAborted) {
-        body.err.forEach((e) => {
-          delete e.params?.hasReplay
-        })
-      }
+      this.#runCrossFeatureChecks(body.err)
       if (!this.errorOnPage) {
         payload.qs.pve = '1'
         this.errorOnPage = true
@@ -172,13 +165,14 @@ export class Aggregate extends AggregateBase {
     // Do not modify the name ('errorGroup') of params without DEM approval!
     if (filterOutput?.group) params.errorGroup = filterOutput.group
 
+    if (hasReplay) 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,
      * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
      * bucketing and ultimately resulting in the loss of data in NR1.
      */
-    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`)
+    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}_${params.hasReplay ? 1 : 0}`)
 
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true
@@ -199,7 +193,6 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
 
-    if (hasReplay && !this.replayAborted) params.hasReplay = hasReplay
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
     params.timestamp = this.observedAt[bucketHash]
 
@@ -296,4 +289,27 @@ export class Aggregate extends AggregateBase {
     )
     delete this.bufferedErrorsUnderSpa[interactionId] // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
+
+  /**
+   * Dispatches a cross-feature communication event to allow other
+   * features to provide flags and data that can be used to mutation
+   * to the payload and to allow features to know about a feature
+   * harvest happening.
+   * @param {any[]} errors Array of errors from the payload body
+   */
+  #runCrossFeatureChecks (errors) {
+    const errorHashes = errors.map(error => error.params.stackHash)
+    const crossFeatureData = {
+      errorHashes
+    }
+    this.ee.emit(`cfc.${this.featureName}`, [crossFeatureData])
+
+    let hasReplayFlag = errors.find(err => err.params.hasReplay)
+    if (hasReplayFlag && !crossFeatureData.hasReplay) {
+      // Some errors have `hasReplay` and a replay is not being recorded
+      errors.forEach(error => {
+        delete error.params.hasReplay
+      })
+    }
+  }
 }

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

@@ -54,11 +54,18 @@ export class Aggregate extends AggregateBase {
     this.timeKeeper = undefined
 
     this.recorder = args?.recorder
-    this.preloaded = !!this.recorder
     this.errorNoticed = args?.errorNoticed || false
 
     handle(SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, FEATURE_NAMES.metrics, this.ee)
 
+    this.ee.on(`cfc.${FEATURE_NAMES.jserrors}`, (crossFeatureData) => {
+      crossFeatureData.hasReplay = !!(this.scheduler?.started &&
+        this.recorder &&
+        this.mode === MODE.FULL &&
+        !this.blocked &&
+        this.entitled)
+    })
+
     // The SessionEntity class can emit a message indicating the session was cleared and reset (expiry, inactivity). This feature must abort and never resume if that occurs.
     this.ee.on(SESSION_EVENTS.RESET, () => {
       this.abort(ABORT_REASONS.RESET)
@@ -104,6 +111,10 @@ export class Aggregate extends AggregateBase {
       this.forceStop(this.mode !== MODE.ERROR)
     }, this.featureName, this.ee)
 
+    registerHandler(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
+      this.handleError(e)
+    }, this.featureName, this.ee)
+
     const { error_sampling_rate, sampling_rate, autoStart, block_selector, mask_text_selector, mask_all_inputs, inline_stylesheet, inline_images, collect_fonts } = getConfigurationValue(this.agentIdentifier, 'session_replay')
 
     this.waitForFlags(['sr']).then(([flagOn]) => {
@@ -148,15 +159,15 @@ export class Aggregate extends AggregateBase {
   }
 
   switchToFull () {
+    if (!this.entitled || this.blocked) return
     this.mode = MODE.FULL
     // if the error was noticed AFTER the recorder was already imported....
     if (this.recorder && this.initialized) {
-      this.recorder.stopRecording()
-      this.recorder.startRecording()
-
+      if (!this.recorder.recording) this.recorder.startRecording()
       this.scheduler.startTimer(this.harvestTimeSeconds)
-
       this.syncWithSessionManager({ sessionReplayMode: this.mode })
+    } else {
+      this.initializeRecording(false, true, true)
     }
   }
 
@@ -213,7 +224,6 @@ export class Aggregate extends AggregateBase {
 
     // If an error was noticed before the mode could be set (like in the early lifecycle of the page), immediately set to FULL mode
     if (this.mode === MODE.ERROR && this.errorNoticed) this.mode = MODE.FULL
-    if (!this.preloaded) this.ee.on('err', e => this.handleError(e))
 
     // FULL mode records AND reports from the beginning, while ERROR mode only records (but does not report).
     // ERROR mode will do this until an error is thrown, and then switch into FULL mode.
@@ -293,7 +303,7 @@ export class Aggregate extends AggregateBase {
   }
 
   getCorrectedTimestamp (node) {
-    if (!node.timestamp) return
+    if (!node?.timestamp) return
     if (node.__newrelic) return node.timestamp
     return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp)
   }

package/src/features/session_replay/constants.js

@@ -6,7 +6,8 @@ export const FEATURE_NAME = FEATURE_NAMES.sessionReplay
 export const SR_EVENT_EMITTER_TYPES = {
   RECORD: 'recordReplay',
   PAUSE: 'pauseReplay',
-  REPLAY_RUNNING: 'replayRunning'
+  REPLAY_RUNNING: 'replayRunning',
+  ERROR_DURING_REPLAY: 'errorDuringReplay'
 }
 
 export const AVG_COMPRESSION = 0.12

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

@@ -9,9 +9,10 @@
  * It is not production ready, and is not intended to be imported or implemented in any build of the browser agent until
  * functionality is validated and a full user experience is curated.
  */
+import { handle } from '../../../common/event-emitter/handle'
 import { DEFAULT_KEY, MODE, PREFIX } from '../../../common/session/constants'
 import { InstrumentBase } from '../../utils/instrument-base'
-import { FEATURE_NAME } from '../constants'
+import { FEATURE_NAME, SR_EVENT_EMITTER_TYPES } from '../constants'
 import { isPreloadAllowed } from '../shared/utils'
 
 export class Instrument extends InstrumentBase {
@@ -19,20 +20,29 @@ export class Instrument extends InstrumentBase {
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
     let session
+    this.replayRunning = false
     try {
       session = JSON.parse(localStorage.getItem(`${PREFIX}_${DEFAULT_KEY}`))
     } catch (err) { }
 
     if (this.#canPreloadRecorder(session)) {
-      /** If this is preloaded, set up a buffer, if not, later when sampling we will set up a .on for live events */
-      this.ee.on('err', (e) => {
-        this.errorNoticed = true
-        if (this.featAggregate) this.featAggregate.handleError()
-      })
       this.#startRecording(session?.sessionReplayMode)
     } else {
       this.importAggregator()
     }
+
+    /** If the recorder is running, we can pass error events on to the agg to help it switch to full mode later */
+    this.ee.on('err', (e) => {
+      if (this.replayRunning) {
+        this.errorNoticed = true
+        handle(SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, [e], undefined, this.featureName, this.ee)
+      }
+    })
+
+    /** Emitted by the recorder when it starts capturing data, used to determine if we should pass errors on to the agg */
+    this.ee.on(SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, (isRunning) => {
+      this.replayRunning = isRunning
+    })
   }
 
   // At this point wherein session state exists already but we haven't init SessionEntity aka verify timers.

package/src/features/session_replay/shared/__mocks__/utils.js

@@ -0,0 +1,2 @@
+export const enableSessionTracking = jest.fn()
+export const canImportReplayAgg = jest.fn()