@newrelic/browser-agent 1.256.0 → 1.257.0

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

@@ -37,13 +37,9 @@ 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', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
@@ -89,11 +85,7 @@ export class Aggregate extends AggregateBase {
       payload.qs.ri = releaseIds;
     }
     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;
@@ -167,14 +159,14 @@ export class Aggregate extends AggregateBase {
     // Notice if filterOutput isn't false|undefined OR our specified object, this func would've returned already (so it's unnecessary to req-check group).
     // 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("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString));
+    var bucketHash = stringHashCode("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString, "_").concat(params.hasReplay ? 1 : 0));
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = truncateSize(stackInfo.stackString);
@@ -193,7 +185,6 @@ export class Aggregate extends AggregateBase {
       params.pageview = 1;
       this.pageviewReported[bucketHash] = true;
     }
-    if (hasReplay && !this.replayAborted) params.hasReplay = hasReplay;
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash];
     params.timestamp = this.observedAt[bucketHash];
     var type = internal ? 'ierr' : 'err';
@@ -288,4 +279,26 @@ 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.".concat(this.featureName), [crossFeatureData]);
+    let hasReplayFlag = errors.find(err => err.params.hasReplay);
+    if (hasReplayFlag && !crossFeatureData.hasReplay) {
+      // Some errors have `hasReplay` and a replay is not being recorded
+      errors.forEach(error => {
+        delete error.params.hasReplay;
+      });
+    }
+  }
 }

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

@@ -52,9 +52,11 @@ export class Aggregate extends AggregateBase {
     /** set at BCS response, stored in runtime */
     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.".concat(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, () => {
@@ -101,6 +103,9 @@ export class Aggregate extends AggregateBase {
     registerHandler(SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       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,
@@ -149,15 +154,17 @@ 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);
     }
   }
 
@@ -218,7 +225,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.
@@ -312,7 +318,7 @@ export class Aggregate extends AggregateBase {
     return [payload];
   }
   getCorrectedTimestamp(node) {
-    if (!node.timestamp) return;
+    if (!node?.timestamp) return;
     if (node.__newrelic) return node.timestamp;
     return this.timeKeeper.correctAbsoluteTimestamp(node.timestamp);
   }

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

@@ -4,7 +4,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;
 export const RRWEB_EVENT_TYPES = {

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/session_trace/aggregate/index.js

@@ -50,11 +50,10 @@ export class Aggregate extends AggregateBase {
     // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.
     if (!this.agentRuntime.xhrWrappable) return;
     this.resourceObserver = argsObj?.resourceObserver; // undefined if observer couldn't be created
-    this.ptid = this.agentRuntime.ptid;
+    this.ptid = '';
     this.trace = {};
     this.nodeCount = 0;
     this.sentTrace = null;
-    this.everSent = false;
     this.harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = getConfigurationValue(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
     /**
@@ -106,7 +105,9 @@ export class Aggregate extends AggregateBase {
         this.isStandalone = false;
         if (prevMode === MODE.ERROR && this.#scheduler) {
           this.trimSTNs(ERROR_MODE_SECONDS_WINDOW); // up until now, Trace would've been just buffering nodes up to max, which needs to be trimmed to last X seconds
-          this.#scheduler.runHarvest({});
+          this.#scheduler.runHarvest({
+            needResponse: true
+          });
         } else {
           controlTraceOp(MODE.FULL);
         }
@@ -129,7 +130,7 @@ export class Aggregate extends AggregateBase {
           sessionTraceMode: MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest({}); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        if (mostRecentModeKnown === MODE.FULL) this.#scheduler?.runHarvest(); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
         this.#scheduler?.stopTimer(true); // the 'true' arg here will forcibly block any future call to runHarvest, so the last runHarvest above must be prior
         this.#scheduler = null;
       };
@@ -148,7 +149,9 @@ export class Aggregate extends AggregateBase {
            - if trace switches to Full mode, harvest should start (prev: Error) if not already running (prev: Full). */
           this.ee.on(SESSION_EVENTS.RESUME, () => {
             const updatedTraceMode = sessionEntity.state.sessionTraceMode;
-            if (updatedTraceMode === MODE.OFF) stopTracePerm();else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({});
+            if (updatedTraceMode === MODE.OFF) stopTracePerm();else if (updatedTraceMode === MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
+              needResponse: true
+            });
             mostRecentModeKnown = updatedTraceMode;
           });
           this.ee.on(SESSION_EVENTS.PAUSE, () => {
@@ -239,12 +242,15 @@ export class Aggregate extends AggregateBase {
       retryDelay: this.harvestTimeSeconds
     }, this);
     this.#scheduler.harvest.on('resources', this.#prepareHarvest.bind(this));
-    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({}); // sends first stn harvest immediately
+    if (dontStartHarvestYet === false) this.#scheduler.runHarvest({
+      needResponse: true
+    }); // sends first stn harvest immediately
     startupBuffer.decide(true); // signal to ALLOW & process data in EE's buffer into internal nodes queued for next harvest
   }
   #onHarvestFinished(result) {
-    if (result.sent && !result.failed && !this.#scheduler.started) {
-      // continue interval harvest only after first call
+    if (result.sent && result.responseText && !this.ptid) {
+      // continue interval harvest only if ptid was returned by server on the first
+      this.agentRuntime.ptid = this.ptid = result.responseText;
       this.#scheduler.startTimer(this.harvestTimeSeconds);
     }
     if (result.sent && result.retry && this.sentTrace) {
@@ -260,18 +266,15 @@ export class Aggregate extends AggregateBase {
   }
   #prepareHarvest(options) {
     if (this.isStandalone) {
-      if (this.#scheduler.started) {
-        if (now() >= MAX_TRACE_DURATION) {
-          // Perform a final harvest once we hit or exceed the max session trace time
-          options.isFinalHarvest = true;
-          this.operationalGate.permanentlyDecide(false);
-          this.#scheduler.stopTimer(true);
-        } else if (this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
-          // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
-          return;
-        }
+      if (this.ptid && now() >= MAX_TRACE_DURATION) {
+        // Perform a final harvest once we hit or exceed the max session trace time
+        options.isFinalHarvest = true;
+        this.operationalGate.permanentlyDecide(false);
+        this.#scheduler.stopTimer(true);
+      } else if (this.ptid && this.nodeCount <= REQ_THRESHOLD_TO_SEND && !options.isFinalHarvest) {
+        // Only harvest when more than some threshold of nodes are pending, after the very first harvest, with the exception of the last outgoing harvest.
+        return;
       }
-      // else, we must be on the very first harvest (standalone mode), so go to next square
     } else {
       //   -- *cli May '26 - Update: Not rate limiting backgrounded pages either for now.
       //   if (this.ptid && document.visibilityState === 'hidden' && this.nodeCount <= REQ_THRESHOLD_TO_SEND) return

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/esm/loaders/configure/configure.js

@@ -54,7 +54,6 @@ export function configure(agent) {
     agent.runSoftNavOverSpa &&= updatedInit.soft_navigations.enabled === true && updatedInit.feature_flags.includes('soft_nav');
   }
   runtime.denyList = [...(updatedInit.ajax.deny_list || []), ...(updatedInit.ajax.block_internal ? internalTrafficList : [])];
-  runtime.ptid = agent.agentIdentifier;
   setRuntime(agent.agentIdentifier, runtime);
   if (agent.api === undefined) agent.api = setAPI(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;

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/session_trace/aggregate/index.d.ts

@@ -3,11 +3,10 @@ export class Aggregate extends AggregateBase {
     constructor(agentIdentifier: any, aggregator: any, argsObj: any);
     agentRuntime: any;
     resourceObserver: any;
-    ptid: any;
+    ptid: string | undefined;
     trace: {} | undefined;
     nodeCount: number | undefined;
     sentTrace: {} | null | undefined;
-    everSent: boolean | undefined;
     harvestTimeSeconds: any;
     maxNodesPerHarvest: any;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiCA;IACE,2BAAiC;IAGjC,iEA6IC;IA3IC,kBAA+C;IAK/C,sBAAiD;IACjD,UAAkC;IAClC,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,8BAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,kCAAyB;IAGzB,0CAAsC;IA0HxC,sEAcC;IA8CD,oDAOC;IAGD,oCAwBC;IAGD,uEAkBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BAhhB6B,4BAA4B;6BAF7B,2BAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiCA;IACE,2BAAiC;IAGjC,iEA4IC;IA1IC,kBAA+C;IAK/C,sBAAiD;IACjD,yBAAc;IACd,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,kCAAyB;IAGzB,0CAAsC;IA0HxC,sEAcC;IA6CD,oDAOC;IAGD,oCAwBC;IAGD,uEAkBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BA9gB6B,4BAA4B;6BAF7B,2BAA2B"}

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/dist/types/loaders/configure/configure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AASA;;GAEG;AACH,oGAgDC"}
+{"version":3,"file":"configure.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/configure.js"],"names":[],"mappings":"AASA;;GAEG;AACH,oGA+CC"}

package/package.json

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