@newrelic/browser-agent 1.252.1 → 1.254.0

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

@@ -18,6 +18,8 @@ import { globalScope } from '../../../common/constants/runtime';
 import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { getNREUMInitializedAgent } from '../../../common/window/nreum';
+import { deregisterDrain } from '../../../common/drain/drain';
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -32,42 +34,41 @@ export class Aggregate extends AggregateBase {
     this.stackReported = {};
     this.observedAt = {};
     this.pageviewReported = {};
-    this.errorCache = {};
+    this.bufferedErrorsUnderSpa = {};
     this.currentBody = undefined;
     this.errorOnPage = false;
 
     // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionSaved', interaction => this.onInteractionSaved(interaction));
-
-    // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionDiscarded', interaction => this.onInteractionDiscarded(interaction));
+    this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved));
     register('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
     register('ierr', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
+    register('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
+
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
-    const scheduler = new HarvestScheduler('jserrors', {
-      onFinished: function () {
-        return _this.onHarvestFinished(...arguments);
-      }
-    }, this);
-    scheduler.harvest.on('jserrors', function () {
-      return _this.onHarvestStarted(...arguments);
-    });
 
-    // Don't start harvesting until "drain" for this feat has been called (which currently requires RUM response).
-    this.ee.on("drain-".concat(this.featureName), () => {
-      if (!this.blocked) scheduler.startTimer(harvestTimeSeconds); // and only if ingest will accept jserror payloads
+    // 0 == off, 1 == on
+    this.waitForFlags(['err']).then(_ref => {
+      let [errFlag] = _ref;
+      if (errFlag) {
+        const scheduler = new HarvestScheduler('jserrors', {
+          onFinished: function () {
+            return _this.onHarvestFinished(...arguments);
+          }
+        }, this);
+        scheduler.harvest.on('jserrors', function () {
+          return _this.onHarvestStarted(...arguments);
+        });
+        scheduler.startTimer(harvestTimeSeconds);
+        this.drain();
+      } else {
+        this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
+        deregisterDrain(this.agentIdentifier, this.featureName);
+      }
     });
-
-    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
-    register('block-err', () => {
-      this.blocked = true;
-      scheduler.stopTimer(true);
-    }, this.featureName, this.ee);
-    this.drain();
   }
   onHarvestStarted(options) {
     // this gets rid of dependency in AJAX module
@@ -188,81 +189,92 @@ export class Aggregate extends AggregateBase {
       time
     };
 
-    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
-    // and spa annotates the error with interaction info
-    const msg = [type, bucketHash, params, newMetrics];
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee);
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee);
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionReplay, this.ee);
-
+    // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
+    const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes];
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee);
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionReplay, this.ee);
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return;
-    var att = getInfo(this.agentIdentifier).jsAttributes;
-    if (params._interactionId != null) {
-      // hold on to the error until the interaction finishes
-      this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || [];
-      this.errorCache[params._interactionId].push([type, bucketHash, params, newMetrics, att, customAttributes]);
+    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav]);
+    // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
+    // They each will also tack on their respective properties to the params object as part of the decision flow.
+    if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee);else handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee);
+    if (params.browserInteractionId && !params._softNavFinished) {
+      // hold onto the error until the in-progress interaction is done, eithered saved or discarded
+      this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= [];
+      this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent);
+    } else if (params._interactionId != null) {
+      // same as above, except tailored for the way old spa does it
+      this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || [];
+      this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent);
     } else {
-      // store custom attributes
-      var customParams = {};
-      mapOwn(att, setCustom);
-      if (customAttributes) {
-        mapOwn(customAttributes, setCustom);
-      }
-      var jsAttributesHash = stringHashCode(stringify(customParams));
-      var aggregateHash = bucketHash + ':' + jsAttributesHash;
-      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams);
+      // Either there is no interaction (then all these params properties will be undefined) OR there's a related soft navigation that's already completed.
+      // The old spa does not look up completed interactions at all, so there's no need to consider it.
+      this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes);
     }
+  }
+  #storeJserrorForHarvest(errorInfoArr, softNavOccurredFinished) {
+    let softNavCustomAttrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr;
+    const allCustomAttrs = {};
+    if (softNavOccurredFinished) {
+      Object.entries(softNavCustomAttrs).forEach(_ref2 => {
+        let [k, v] = _ref2;
+        return setCustom(k, v);
+      }); // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
+      bucketHash += params.browserInteractionId;
+      delete params._softNavAttributes; // cleanup temp properties from synchronous evaluation; this is harmless when async from soft nav (properties DNE)
+      delete params._softNavFinished;
+    } else {
+      // interaction was cancelled -> error should not be associated OR there was no interaction
+      Object.entries(getInfo(this.agentIdentifier).jsAttributes).forEach(_ref3 => {
+        let [k, v] = _ref3;
+        return setCustom(k, v);
+      });
+      delete params.browserInteractionId;
+    }
+    if (localAttrs) Object.entries(localAttrs).forEach(_ref4 => {
+      let [k, v] = _ref4;
+      return setCustom(k, v);
+    }); // local custom attrs are applied in either case with the highest precedence
+
+    const jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
+    const aggregateHash = bucketHash + ':' + jsAttributesHash;
+    this.aggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs);
     function setCustom(key, val) {
-      customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+      allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
     }
   }
-  onInteractionSaved(interaction) {
-    if (!this.errorCache[interaction.id] || this.blocked) return;
-    this.errorCache[interaction.id].forEach(item => {
-      var customParams = {};
-      var globalCustomParams = item[4];
-      var localCustomParams = item[5];
-      mapOwn(globalCustomParams, setCustom);
-      mapOwn(interaction.root.attrs.custom, setCustom);
-      mapOwn(localCustomParams, setCustom);
+
+  // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.
+  onInteractionDone(interaction, wasSaved) {
+    if (!this.bufferedErrorsUnderSpa[interaction.id] || this.blocked) return;
+    this.bufferedErrorsUnderSpa[interaction.id].forEach(item => {
+      var allCustomAttrs = {};
+      const localCustomAttrs = item[4];
+      mapOwn(interaction.root.attrs.custom, setCustom); // tack on custom attrs from the interaction
+      mapOwn(localCustomAttrs, setCustom);
       var params = item[2];
-      params.browserInteractionId = interaction.root.attrs.id;
-      delete params._interactionId;
-      if (params._interactionNodeId) {
-        params.parentNodeId = params._interactionNodeId.toString();
-        delete params._interactionNodeId;
-      }
-      var hash = item[1] + interaction.root.attrs.id;
-      var jsAttributesHash = stringHashCode(stringify(customParams));
-      var aggregateHash = hash + ':' + jsAttributesHash;
-      this.aggregator.store(item[0], aggregateHash, params, item[3], customParams);
-      function setCustom(key, val) {
-        customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+      if (wasSaved) {
+        params.browserInteractionId = interaction.root.attrs.id;
+        if (params._interactionNodeId) params.parentNodeId = params._interactionNodeId.toString();
       }
-    });
-    delete this.errorCache[interaction.id];
-  }
-  onInteractionDiscarded(interaction) {
-    if (!this.errorCache || !this.errorCache[interaction.id] || this.blocked) return;
-    this.errorCache[interaction.id].forEach(item => {
-      var customParams = {};
-      var globalCustomParams = item[4];
-      var localCustomParams = item[5];
-      mapOwn(globalCustomParams, setCustom);
-      mapOwn(interaction.root.attrs.custom, setCustom);
-      mapOwn(localCustomParams, setCustom);
-      var params = item[2];
       delete params._interactionId;
       delete params._interactionNodeId;
-      var hash = item[1];
-      var jsAttributesHash = stringHashCode(stringify(customParams));
+      var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
+      var jsAttributesHash = stringHashCode(stringify(allCustomAttrs));
       var aggregateHash = hash + ':' + jsAttributesHash;
-      this.aggregator.store(item[0], aggregateHash, item[2], item[3], customParams);
+      this.aggregator.store(item[0], aggregateHash, params, item[3], allCustomAttrs);
       function setCustom(key, val) {
-        customParams[key] = val && typeof val === 'object' ? stringify(val) : val;
+        allCustomAttrs[key] = val && typeof val === 'object' ? stringify(val) : val;
       }
     });
-    delete this.errorCache[interaction.id];
+    delete this.bufferedErrorsUnderSpa[interaction.id];
+  }
+  onSoftNavNotification(interactionId, wasFinished, softNavAttrs) {
+    if (this.blocked) return;
+    this.bufferedErrorsUnderSpa[interactionId]?.forEach(jsErrorEvent => this.#storeJserrorForHarvest(jsErrorEvent, wasFinished, softNavAttrs) // this should not modify the re-used softNavAttrs contents
+    );
+    delete this.bufferedErrorsUnderSpa[interactionId]; // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
 }

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

@@ -9,35 +9,34 @@ import { onDOMContentLoaded } from '../../../common/window/load';
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts';
 import { isBrowserScope, isWorkerScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { deregisterDrain } from '../../../common/drain/drain';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
-    let scheduler;
-
-    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
-    registerHandler('block-err', () => {
-      this.blocked = true;
-      if (scheduler) scheduler.aborted = true; // RUM response may or may not have happened already before scheduler initialization below
-    }, this.featureName, this.ee);
+    this.waitForFlags(['err']).then(_ref => {
+      let [errFlag] = _ref;
+      if (errFlag) {
+        // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
+        const scheduler = new HarvestScheduler('jserrors', {
+          onUnload: () => this.unload()
+        }, this);
+        // this is needed to ensure EoL is "on" and sent
+        scheduler.harvest.on('jserrors', () => ({
+          body: this.aggregator.take(['cm', 'sm'])
+        }));
+        this.drain();
+      } else {
+        this.blocked = true; // if rum response determines that customer lacks entitlements for spa endpoint, this feature shouldn't harvest
+        deregisterDrain(this.agentIdentifier, this.featureName);
+      }
+    });
 
     // Allow features external to the metrics feature to capture SMs and CMs through the event emitter
     registerHandler(SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee);
     registerHandler(CUSTOM_METRIC_CHANNEL, this.storeEventMetrics.bind(this), this.featureName, this.ee);
     this.singleChecks(); // checks that are run only one time, at script load
     this.eachSessionChecks(); // the start of every time user engages with page
-
-    this.ee.on("drain-".concat(this.featureName), () => {
-      // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
-      scheduler = new HarvestScheduler('jserrors', {
-        onUnload: () => this.unload()
-      }, this);
-      scheduler.harvest.on('jserrors', () => ({
-        body: this.aggregator.take(['cm', 'sm'])
-      }));
-    }); // this is needed to ensure EoL is "on" and sent
-
-    this.drain();
   }
   storeSupportabilityMetrics(name, value) {
     if (this.blocked) return;
@@ -61,6 +60,11 @@ export class Aggregate extends AggregateBase {
       distMethod,
       loaderType
     } = getRuntime(this.agentIdentifier);
+    const {
+      proxy,
+      privacy,
+      page_view_timing
+    } = getConfiguration(this.agentIdentifier);
     if (loaderType) this.storeSupportabilityMetrics("Generic/LoaderType/".concat(loaderType, "/Detected"));
     if (distMethod) this.storeSupportabilityMetrics("Generic/DistMethod/".concat(distMethod, "/Detected"));
     if (isBrowserScope) {
@@ -76,6 +80,8 @@ export class Aggregate extends AggregateBase {
           this.storeSupportabilityMetrics('Framework/' + framework + '/Detected');
         });
       });
+      if (!privacy.cookies_enabled) this.storeSupportabilityMetrics('Config/SessionTracking/Disabled');
+      if (page_view_timing.long_task) this.storeSupportabilityMetrics('Config/LongTask/Enabled');
     } else if (isWorkerScope) {
       this.storeSupportabilityMetrics('Generic/Runtime/Worker/Detected');
     } else {
@@ -94,13 +100,8 @@ export class Aggregate extends AggregateBase {
     if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
 
     // Check if proxy for either chunks or beacon is being used
-    const {
-      proxy,
-      privacy
-    } = getConfiguration(this.agentIdentifier);
     if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed');
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed');
-    if (!(isBrowserScope && privacy.cookies_enabled)) this.storeSupportabilityMetrics('Config/SessionTracking/Disabled');
   }
   eachSessionChecks() {
     if (!isBrowserScope) return;

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

@@ -12,6 +12,7 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { FEATURE_NAME } from '../constants';
 import { isBrowserScope } from '../../../common/constants/runtime';
 import { AggregateBase } from '../../utils/aggregate-base';
+import { deregisterDrain } from '../../../common/drain/drain';
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -31,8 +32,8 @@ export class Aggregate extends AggregateBase {
       return _this.addPageAction(...arguments);
     }, this.featureName, this.ee);
     this.waitForFlags(['ins']).then(_ref => {
-      let [enabled] = _ref;
-      if (enabled) {
+      let [insFlag] = _ref;
+      if (insFlag) {
         const scheduler = new HarvestScheduler('ins', {
           onFinished: function () {
             return _this.onHarvestFinished(...arguments);
@@ -42,11 +43,12 @@ export class Aggregate extends AggregateBase {
           return _this.onHarvestStarted(...arguments);
         });
         scheduler.startTimer(this.harvestTimeSeconds, 0);
+        this.drain();
       } else {
-        this.blocked = true;
+        this.blocked = true; // if rum response determines that customer lacks entitlements for ins endpoint, this feature shouldn't harvest
+        deregisterDrain(this.agentIdentifier, this.featureName);
       }
     });
-    this.drain();
   }
   onHarvestStarted(options) {
     const {

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

@@ -11,6 +11,10 @@ import { AggregateBase } from '../../utils/aggregate-base';
 import { firstContentfulPaint } from '../../../common/vitals/first-contentful-paint';
 import { firstPaint } from '../../../common/vitals/first-paint';
 import { timeToFirstByte } from '../../../common/vitals/time-to-first-byte';
+import { drain } from '../../../common/drain/drain';
+import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { handle } from '../../../common/event-emitter/handle';
+import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants';
 export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
@@ -117,7 +121,9 @@ export class Aggregate extends AggregateBase {
       cbFinished: _ref3 => {
         let {
           status,
-          responseText
+          responseText,
+          xhr,
+          fullUrl
         } = _ref3;
         if (status >= 400 || status === 0) {
           // Adding retry logic for the rum call will be a separate change
@@ -125,11 +131,25 @@ export class Aggregate extends AggregateBase {
           return;
         }
         try {
-          activateFeatures(JSON.parse(responseText), this.agentIdentifier);
+          this.timeKeeper.processRumRequest(xhr, fullUrl);
+        } catch (error) {
+          handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, FEATURE_NAMES.metrics, this.ee);
+          drain(this.agentIdentifier, FEATURE_NAMES.metrics, true);
+          this.ee.abort();
+          warn('Could not calculate New Relic server time. Agent shutting down.');
+          return;
+        }
+        try {
+          const {
+            app,
+            ...flags
+          } = JSON.parse(responseText);
+          agentRuntime.appMetadata = app;
+          activateFeatures(flags, this.agentIdentifier);
           this.drain();
         } catch (err) {
           this.ee.abort();
-          warn('RUM call failed. Agent shutting down.');
+          warn('RUM call failed. Agent shutting down.', err);
         }
       }
     });

package/dist/esm/features/page_view_event/aggregate/initialized-features.js

@@ -25,6 +25,7 @@ export function getActivatedFeaturesFlags(agentId) {
         case FEATURE_NAMES.sessionTrace:
           flagArr.push('stn');
           break;
+        case FEATURE_NAMES.softNav:
         case FEATURE_NAMES.spa:
           flagArr.push('spa');
           break;

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

@@ -37,17 +37,6 @@ export class Aggregate extends AggregateBase {
     this.timings = [];
     this.timingsSent = [];
     this.curSessEndRecorded = false;
-    firstPaint.subscribe(this.#handleVitalMetric);
-    firstContentfulPaint.subscribe(this.#handleVitalMetric);
-    firstInputDelay.subscribe(this.#handleVitalMetric);
-    largestContentfulPaint.subscribe(this.#handleVitalMetric);
-    interactionToNextPaint.subscribe(this.#handleVitalMetric);
-    timeToFirstByte.subscribe(_ref2 => {
-      let {
-        entries
-      } = _ref2;
-      this.addTiming('load', Math.round(entries[0].loadEventEnd));
-    });
     if (getConfigurationValue(this.agentIdentifier, 'page_view_timing.long_task') === true) longTask.subscribe(this.#handleVitalMetric);
 
     /* It's important that CWV api, like "onLCP", is called before this scheduler is initialized. The reason is because they listen to the same
@@ -57,9 +46,19 @@ export class Aggregate extends AggregateBase {
     registerHandler('winPagehide', msTimestamp => this.recordPageUnload(msTimestamp), this.featureName, this.ee);
     const initialHarvestSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.initialHarvestSeconds') || 10;
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'page_view_timing.harvestTimeSeconds') || 30;
-    // send initial data sooner, then start regular
-    this.ee.on("drain-".concat(this.featureName), () => {
-      this.scheduler = new HarvestScheduler('events', {
+    this.waitForFlags([]).then(() => {
+      firstPaint.subscribe(this.#handleVitalMetric);
+      firstContentfulPaint.subscribe(this.#handleVitalMetric);
+      firstInputDelay.subscribe(this.#handleVitalMetric);
+      largestContentfulPaint.subscribe(this.#handleVitalMetric);
+      interactionToNextPaint.subscribe(this.#handleVitalMetric);
+      timeToFirstByte.subscribe(_ref2 => {
+        let {
+          entries
+        } = _ref2;
+        this.addTiming('load', Math.round(entries[0].loadEventEnd));
+      });
+      const scheduler = new HarvestScheduler('events', {
         onFinished: function () {
           return _this.onHarvestFinished(...arguments);
         },
@@ -67,9 +66,9 @@ export class Aggregate extends AggregateBase {
           return _this.prepareHarvest(...arguments);
         }
       }, this);
-      this.scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds);
+      scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds);
+      this.drain();
     });
-    this.drain();
   }
 
   /**