@newrelic/browser-agent 1.256.0 → 1.257.0

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.257.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.256.1...v1.257.0) (2024-04-18)
+
+
+### Features
+
+* Decorate errors with hasReplay individually ([#983](https://github.com/newrelic/newrelic-browser-agent/issues/983)) ([b6a7a3e](https://github.com/newrelic/newrelic-browser-agent/commit/b6a7a3ebcf2a69b9cbe9888208bb62330918cdf7))
+* Session Replay preload optimizations ([#982](https://github.com/newrelic/newrelic-browser-agent/issues/982)) ([fa20693](https://github.com/newrelic/newrelic-browser-agent/commit/fa20693d746bed2fa0b8ff972e4b9bee4bbe6956))
+
+
+### Bug Fixes
+
+* Agent class type declarations ([#987](https://github.com/newrelic/newrelic-browser-agent/issues/987)) ([b682c88](https://github.com/newrelic/newrelic-browser-agent/commit/b682c880bfb149b61f6c00bf821459ea55a37ae8))
+* JSEerrors harvest hasReplay decoration ([#986](https://github.com/newrelic/newrelic-browser-agent/issues/986)) ([6dd09c5](https://github.com/newrelic/newrelic-browser-agent/commit/6dd09c505af87b3a1b08330362eca46951ea22ed))
+* Session replay preload without autoStart ([#985](https://github.com/newrelic/newrelic-browser-agent/issues/985)) ([f50351a](https://github.com/newrelic/newrelic-browser-agent/commit/f50351acb08b65b03e7f4b5530a001a80fc04ece))
+* Soft navigations memory leak on harvest ([#979](https://github.com/newrelic/newrelic-browser-agent/issues/979)) ([53bb120](https://github.com/newrelic/newrelic-browser-agent/commit/53bb1209cb66fe1a52385b2863e35a93fb29afae))
+
+## [1.256.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.256.0...v1.256.1) (2024-04-15)
+
+
+### Bug Fixes
+
+* Revert "Generate PTID in Agent" ([#976](https://github.com/newrelic/newrelic-browser-agent/issues/976)) ([34b317f](https://github.com/newrelic/newrelic-browser-agent/commit/34b317fe577487af56d48861b7f256ec8d644d69))
+
 ## [1.256.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.255.0...v1.256.0) (2024-04-11)
 
 

package/dist/cjs/common/constants/env.cdn.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.256.0";
+const VERSION = exports.VERSION = "1.257.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/constants/env.npm.js

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.256.0";
+const VERSION = exports.VERSION = "1.257.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/harvest/harvest.js

@@ -137,7 +137,7 @@ class Harvest extends _sharedContext.SharedContext {
     let url = "".concat(protocol, "://").concat(perceviedBeacon).concat(endpointURLPart, "/1/").concat(info.licenseKey);
     if (customUrl) url = customUrl;
     if (raw) url = "".concat(protocol, "://").concat(perceviedBeacon, "/").concat(endpoint);
-    const baseParams = !raw && includeBaseParams ? this.baseQueryString(qs) : '';
+    const baseParams = !raw && includeBaseParams ? this.baseQueryString(qs, endpoint) : '';
     let payloadParams = (0, _encode.obj)(qs, agentRuntime.maxBytes);
     if (!submitMethod) {
       submitMethod = submitData.getSubmitMethod({
@@ -186,7 +186,6 @@ class Harvest extends _sharedContext.SharedContext {
         const cbResult = {
           sent: this.status !== 0,
           status: this.status,
-          failed: this.status === 0 || this.status >= 400,
           xhr: this,
           fullUrl
         };
@@ -208,17 +207,19 @@ class Harvest extends _sharedContext.SharedContext {
   }
 
   // The stuff that gets sent every time.
-  baseQueryString(qs) {
+  baseQueryString(qs, endpoint) {
     const runtime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
     const info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     const location = (0, _cleanUrl.cleanURL)((0, _location.getLocation)());
     const ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
-    return ['a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
+    const hr = runtime?.session?.state.sessionReplayMode === 1 && endpoint !== 'jserrors';
+    const qps = ['a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
     // ck param DEPRECATED - still expected by backend
     '&s=' + (runtime.session?.state.value || '0'),
     // the 0 id encaps all untrackable and default traffic
-    (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', runtime.ptid ? '' + runtime.ptid : ''), (0, _encode.param)('hr', runtime?.session?.state.sessionReplayMode === 1 ? '1' : '0', qs) // hasReplay
-    ].join('');
+    (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', runtime.ptid ? '' + runtime.ptid : '')];
+    if (hr) qps.push((0, _encode.param)('hr', '1', qs));
+    return qps.join('');
   }
 
   /**

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

@@ -42,13 +42,9 @@ class Aggregate extends _aggregateBase.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;
-    });
     (0, _registerHandler.registerHandler)('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
@@ -94,11 +90,7 @@ class Aggregate extends _aggregateBase.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;
@@ -172,14 +164,14 @@ class Aggregate extends _aggregateBase.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 = (0, _stringHashCode.stringHashCode)("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString));
+    var bucketHash = (0, _stringHashCode.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 = (0, _formatStackTrace.truncateSize)(stackInfo.stackString);
@@ -198,7 +190,6 @@ class Aggregate extends _aggregateBase.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';
@@ -293,5 +284,27 @@ class Aggregate extends _aggregateBase.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;
+      });
+    }
+  }
 }
 exports.Aggregate = Aggregate;

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

@@ -57,9 +57,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
     /** set at BCS response, stored in runtime */
     this.timeKeeper = undefined;
     this.recorder = args?.recorder;
-    this.preloaded = !!this.recorder;
     this.errorNoticed = args?.errorNoticed || false;
     (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Config/SessionReplay/Enabled'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+    this.ee.on("cfc.".concat(_features.FEATURE_NAMES.jserrors), crossFeatureData => {
+      crossFeatureData.hasReplay = !!(this.scheduler?.started && this.recorder && this.mode === _constants3.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(_constants3.SESSION_EVENTS.RESET, () => {
@@ -106,6 +108,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.PAUSE, () => {
       this.forceStop(this.mode !== _constants3.MODE.ERROR);
     }, this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)(_constants.SR_EVENT_EMITTER_TYPES.ERROR_DURING_REPLAY, e => {
+      this.handleError(e);
+    }, this.featureName, this.ee);
     const {
       error_sampling_rate,
       sampling_rate,
@@ -154,15 +159,17 @@ class Aggregate extends _aggregateBase.AggregateBase {
     }
   }
   switchToFull() {
+    if (!this.entitled || this.blocked) return;
     this.mode = _constants3.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);
     }
   }
 
@@ -223,7 +230,6 @@ class Aggregate extends _aggregateBase.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 === _constants3.MODE.ERROR && this.errorNoticed) this.mode = _constants3.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.
@@ -317,7 +323,7 @@ class Aggregate extends _aggregateBase.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/cjs/features/session_replay/constants.js

@@ -10,7 +10,8 @@ const FEATURE_NAME = exports.FEATURE_NAME = _features.FEATURE_NAMES.sessionRepla
 const SR_EVENT_EMITTER_TYPES = exports.SR_EVENT_EMITTER_TYPES = {
   RECORD: 'recordReplay',
   PAUSE: 'pauseReplay',
-  REPLAY_RUNNING: 'replayRunning'
+  REPLAY_RUNNING: 'replayRunning',
+  ERROR_DURING_REPLAY: 'errorDuringReplay'
 };
 const AVG_COMPRESSION = exports.AVG_COMPRESSION = 0.12;
 const RRWEB_EVENT_TYPES = exports.RRWEB_EVENT_TYPES = {

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Instrument = void 0;
+var _handle = require("../../../common/event-emitter/handle");
 var _constants = require("../../../common/session/constants");
 var _instrumentBase = require("../../utils/instrument-base");
 var _constants2 = require("../constants");
@@ -25,19 +26,28 @@ class Instrument extends _instrumentBase.InstrumentBase {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants2.FEATURE_NAME, auto);
     let session;
+    this.replayRunning = false;
     try {
       session = JSON.parse(localStorage.getItem("".concat(_constants.PREFIX, "_").concat(_constants.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;
+        (0, _handle.handle)(_constants2.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(_constants2.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/cjs/features/session_replay/shared/recorder.js

@@ -103,11 +103,10 @@ class Recorder {
       collectFonts: collect_fonts,
       checkoutEveryNms: _constants.CHECKOUT_MS[this.parent.mode]
     });
-    this.parent.ee.emit(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
     this.stopRecording = () => {
       this.recording = false;
       this.parent.ee.emit(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [false, this.parent.mode]);
-      stop();
+      stop?.();
     };
   }
 
@@ -150,6 +149,10 @@ 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(_constants.SR_EVENT_EMITTER_TYPES.REPLAY_RUNNING, [true, this.parent.mode]);
+      this.notified = true;
+    }
     if (this.parent.timeKeeper?.ready && !event.__newrelic) {
       event.__newrelic = (0, _utils.buildNRMetaNode)(event.timestamp, this.parent.timeKeeper);
       event.timestamp = this.parent.timeKeeper.correctAbsoluteTimestamp(event.timestamp);
@@ -180,7 +183,7 @@ 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 > _constants.IDEAL_PAYLOAD_SIZE && this.parent.mode !== _constants2.MODE.ERROR) {
+    if ((event.type === _constants.RRWEB_EVENT_TYPES.FullSnapshot && this.currentBufferTarget.hasMeta || payloadSize > _constants.IDEAL_PAYLOAD_SIZE) && this.parent.mode === _constants2.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/cjs/features/session_replay/shared/utils.js

@@ -5,16 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildNRMetaNode = buildNRMetaNode;
 exports.canImportReplayAgg = canImportReplayAgg;
-exports.enableSessionTracking = void 0;
+exports.enableSessionTracking = enableSessionTracking;
 exports.isPreloadAllowed = isPreloadAllowed;
 var _config = require("../../../common/config/config");
 var _runtime = require("../../../common/constants/runtime");
-const enableSessionTracking = agentId => _runtime.isBrowserScope && (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') === true;
-exports.enableSessionTracking = enableSessionTracking;
+function enableSessionTracking(agentId) {
+  return _runtime.isBrowserScope && (0, _config.getConfigurationValue)(agentId, 'privacy.cookies_enabled') === true;
+}
 function hasReplayPrerequisite(agentId) {
-  return _config.originals.MO &&
+  return !!_config.originals.MO &&
   // Session Replay cannot work without Mutation Observer
-  enableSessionTracking &&
+  enableSessionTracking(agentId) &&
   // requires session tracking to be running (hence "session" replay...)
   (0, _config.getConfigurationValue)(agentId, 'session_trace.enabled') === true; // Session Replay as of now is tightly coupled with Session Trace in the UI
 }

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

@@ -57,11 +57,10 @@ class Aggregate extends _aggregateBase.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 = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.harvestTimeSeconds') || 10;
     this.maxNodesPerHarvest = (0, _config.getConfigurationValue)(agentIdentifier, 'session_trace.maxNodesPerHarvest') || 1000;
     /**
@@ -113,7 +112,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
         this.isStandalone = false;
         if (prevMode === _constants2.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(_constants2.MODE.FULL);
         }
@@ -136,7 +137,7 @@ class Aggregate extends _aggregateBase.AggregateBase {
           sessionTraceMode: _constants2.MODE.OFF
         });
         operationalGate.permanentlyDecide(false);
-        if (mostRecentModeKnown === _constants2.MODE.FULL) this.#scheduler?.runHarvest({}); // allow queued nodes (past opGate) to final harvest, unless they were buffered in other modes
+        if (mostRecentModeKnown === _constants2.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;
       };
@@ -155,7 +156,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
            - if trace switches to Full mode, harvest should start (prev: Error) if not already running (prev: Full). */
           this.ee.on(_constants2.SESSION_EVENTS.RESUME, () => {
             const updatedTraceMode = sessionEntity.state.sessionTraceMode;
-            if (updatedTraceMode === _constants2.MODE.OFF) stopTracePerm();else if (updatedTraceMode === _constants2.MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({});
+            if (updatedTraceMode === _constants2.MODE.OFF) stopTracePerm();else if (updatedTraceMode === _constants2.MODE.FULL && this.#scheduler && !this.#scheduler.started) this.#scheduler.runHarvest({
+              needResponse: true
+            });
             mostRecentModeKnown = updatedTraceMode;
           });
           this.ee.on(_constants2.SESSION_EVENTS.PAUSE, () => {
@@ -246,12 +249,15 @@ class Aggregate extends _aggregateBase.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) {
@@ -267,18 +273,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
   }
   #prepareHarvest(options) {
     if (this.isStandalone) {
-      if (this.#scheduler.started) {
-        if ((0, _now.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 && (0, _now.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/cjs/features/soft_navigations/aggregate/index.js

@@ -88,7 +88,7 @@ class Aggregate extends _aggregateBase.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: {
@@ -99,8 +99,8 @@ class Aggregate extends _aggregateBase.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/cjs/features/utils/instrument-base.js

@@ -12,6 +12,7 @@ var _console = require("../../common/util/console");
 var _features = require("../../loaders/features/features");
 var _config = require("../../common/config/config");
 var _utils = require("../session_replay/shared/utils");
+var _invoke = require("../../common/util/invoke");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; } /**
  * @file Defines `InstrumentBase` to be used as the super of the Instrument classes implemented by each feature.
@@ -55,7 +56,15 @@ class InstrumentBase extends _featureBase.FeatureBase {
     /** used in conjunction with newrelic.start() to defer harvesting in features */
     if ((0, _config.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) (0, _drain.registerDrain)(agentIdentifier, featureName);
+    if (this.auto) (0, _drain.registerDrain)(agentIdentifier, featureName);else {
+      this.ee.on("".concat(this.featureName, "-opt-in"), (0, _invoke.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
+        (0, _drain.registerDrain)(this.agentIdentifier, this.featureName);
+        this.auto = true;
+        this.importAggregator();
+      }));
+    }
   }
 
   /**
@@ -66,19 +75,7 @@ class InstrumentBase extends _featureBase.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
-        (0, _drain.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/cjs/features/utils/nr1-debugger.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debugNR1 = debugNR1;
+var _nreum = require("../../common/window/nreum");
+const debugId = 1;
+const newrelic = (0, _nreum.gosCDN)();
+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/cjs/loaders/agent.js

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

package/dist/cjs/loaders/configure/configure.js

@@ -60,7 +60,6 @@ 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;
   (0, _config.setRuntime)(agent.agentIdentifier, runtime);
   if (agent.api === undefined) agent.api = (0, _api.setAPI)(agent.agentIdentifier, forceDrain, agent.runSoftNavOverSpa);
   if (agent.exposed === undefined) agent.exposed = exposed;

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.256.0";
+export const VERSION = "1.257.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.256.0";
+export const VERSION = "1.257.0";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/harvest/harvest.js

@@ -129,7 +129,7 @@ export class Harvest extends SharedContext {
     let url = "".concat(protocol, "://").concat(perceviedBeacon).concat(endpointURLPart, "/1/").concat(info.licenseKey);
     if (customUrl) url = customUrl;
     if (raw) url = "".concat(protocol, "://").concat(perceviedBeacon, "/").concat(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({
@@ -178,7 +178,6 @@ export class Harvest extends SharedContext {
         const cbResult = {
           sent: this.status !== 0,
           status: this.status,
-          failed: this.status === 0 || this.status >= 400,
           xhr: this,
           fullUrl
         };
@@ -200,17 +199,19 @@ 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;
-    return ['a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&ck=0',
+    const hr = runtime?.session?.state.sessionReplayMode === 1 && endpoint !== 'jserrors';
+    const qps = ['a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&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('ref', ref), encodeParam('ptid', runtime.ptid ? '' + runtime.ptid : '')];
+    if (hr) qps.push(encodeParam('hr', '1', qs));
+    return qps.join('');
   }
 
   /**