@newrelic/browser-agent 1.252.1 → 1.254.0

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

@@ -16,6 +16,7 @@ var _features = require("../../../loaders/features/features");
 var _constants2 = require("../../metrics/constants");
 var _aggregateBase = require("../../utils/aggregate-base");
 var _gql = require("./gql");
+var _nreum = require("../../../common/window/nreum");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -26,12 +27,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
     const agentInit = (0, _config.getConfiguration)(agentIdentifier);
-    const allAjaxIsEnabled = agentInit.ajax.enabled !== false;
     (0, _registerHandler.registerHandler)('xhr', storeXhr, this.featureName, this.ee);
-    if (!allAjaxIsEnabled) {
+    this.waitForFlags([]).then(() => {
+      const scheduler = new _harvestScheduler.HarvestScheduler('events', {
+        onFinished: onEventsHarvestFinished,
+        getPayload: prepareHarvest
+      }, this);
+      scheduler.startTimer(harvestTimeSeconds);
       this.drain();
-      return; // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
-    }
+    });
     const denyList = (0, _config.getRuntime)(agentIdentifier).denyList;
     (0, _denyList.setDenyList)(denyList);
     let ajaxEvents = [];
@@ -50,27 +54,23 @@ class Aggregate extends _aggregateBase.AggregateBase {
         spaAjaxEvents
       };
     };
-    ee.on('interactionSaved', interaction => {
-      if (!spaAjaxEvents[interaction.id]) return;
-      // remove from the spaAjaxEvents buffer, and let spa harvest it
-      delete spaAjaxEvents[interaction.id];
-    });
-    ee.on('interactionDiscarded', interaction => {
+
+    // --- v Used by old spa feature
+    ee.on('interactionDone', (interaction, wasSaved) => {
       if (!spaAjaxEvents[interaction.id]) return;
-      spaAjaxEvents[interaction.id].forEach(function (item) {
-        // move it from the spaAjaxEvents buffer to the ajaxEvents buffer for harvesting here
-        ajaxEvents.push(item);
-      });
+      if (!wasSaved) {
+        // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
+        spaAjaxEvents[interaction.id].forEach(function (item) {
+          ajaxEvents.push(item);
+        });
+      }
       delete spaAjaxEvents[interaction.id];
     });
-    const scheduler = new _harvestScheduler.HarvestScheduler('events', {
-      onFinished: onEventsHarvestFinished,
-      getPayload: prepareHarvest
-    }, this);
-    ee.on("drain-".concat(this.featureName), () => {
-      scheduler.startTimer(harvestTimeSeconds);
-    });
-    this.drain();
+    // --- ^
+    // --- v Used by new soft nav
+    (0, _registerHandler.registerHandler)('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
+    // --- ^
+
     const beacon = (0, _config.getInfo)(agentIdentifier).errorBeacon;
     const proxyBeacon = agentInit.proxy.beacon;
     function storeXhr(params, metrics, startTime, endTime, type) {
@@ -83,16 +83,25 @@ class Aggregate extends _aggregateBase.AggregateBase {
       } else {
         hash = (0, _stringify.stringify)([params.status, params.host, params.pathname]);
       }
+      const shouldCollect = (0, _denyList.shouldCollectEvent)(params);
+      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list');
 
       // store as metric
-      aggregator.store('xhr', hash, params, metrics);
-      if (!allAjaxIsEnabled) return;
-      if (!(0, _denyList.shouldCollectEvent)(params)) {
+      if (shouldCollect || !ajaxMetricDenyListEnabled) {
+        aggregator.store('xhr', hash, params, metrics);
+      }
+      if (!shouldCollect) {
         if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
           // This doesn't make a distinction if the same-domain request is going to a different port or path...
           (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, _features.FEATURE_NAMES.metrics, ee);
+          if (ajaxMetricDenyListEnabled) {
+            (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, _features.FEATURE_NAMES.metrics, ee);
+          }
         } else {
           (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, _features.FEATURE_NAMES.metrics, ee);
+          if (ajaxMetricDenyListEnabled) {
+            (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, _features.FEATURE_NAMES.metrics, ee);
+          }
         }
         return;
       }
@@ -122,10 +131,13 @@ class Aggregate extends _aggregateBase.AggregateBase {
         query: this?.parsedOrigin?.search
       });
       if (event.gql) (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', (0, _stringify.stringify)(event.gql).length], undefined, _features.FEATURE_NAMES.metrics, ee);
-
-      // if the ajax happened inside an interaction, hold it until the interaction finishes
-      if (this.spaNode) {
-        var interactionId = this.spaNode.interaction.id;
+      const softNavInUse = Boolean((0, _nreum.getNREUMInitializedAgent)(agentIdentifier)?.features?.[_features.FEATURE_NAMES.softNav]);
+      if (softNavInUse) {
+        // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
+        (0, _handle.handle)('ajax', [event], undefined, _features.FEATURE_NAMES.softNav, ee);
+      } else if (this.spaNode) {
+        // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
+        const interactionId = this.spaNode.interaction.id;
         spaAjaxEvents[interactionId] = spaAjaxEvents[interactionId] || [];
         spaAjaxEvents[interactionId].push(event);
       } else {

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

@@ -19,6 +19,8 @@ var _runtime = require("../../../common/constants/runtime");
 var _constants = require("../constants");
 var _features = require("../../../loaders/features/features");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _nreum = require("../../../common/window/nreum");
+var _drain = require("../../../common/drain/drain");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -37,42 +39,41 @@ class Aggregate extends _aggregateBase.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));
     (0, _registerHandler.registerHandler)('err', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
     (0, _registerHandler.registerHandler)('ierr', function () {
       return _this.storeError(...arguments);
     }, this.featureName, this.ee);
+    (0, _registerHandler.registerHandler)('softNavFlush', (interactionId, wasFinished, softNavAttrs) => this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee); // when an ixn is done or cancelled
+
     const harvestTimeSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10;
-    const scheduler = new _harvestScheduler.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.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
+        (0, _drain.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.
-    (0, _registerHandler.registerHandler)('block-err', () => {
-      this.blocked = true;
-      scheduler.stopTimer(true);
-    }, this.featureName, this.ee);
-    this.drain();
   }
   onHarvestStarted(options) {
     // this gets rid of dependency in AJAX module
@@ -193,82 +194,93 @@ class Aggregate extends _aggregateBase.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];
-    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
-    (0, _handle.handle)('errorAgg', msg, undefined, _features.FEATURE_NAMES.spa, this.ee);
-    (0, _handle.handle)('errorAgg', msg, undefined, _features.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];
+    (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.FEATURE_NAMES.sessionTrace, this.ee);
+    (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.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 = (0, _config.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((0, _nreum.getNREUMInitializedAgent)(this.agentIdentifier)?.features[_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) (0, _handle.handle)('jserror', [params, time], undefined, _features.FEATURE_NAMES.softNav, this.ee);else (0, _handle.handle)('errorAgg', jsErrorEvent, undefined, _features.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 = {};
-      (0, _mapOwn.mapOwn)(att, setCustom);
-      if (customAttributes) {
-        (0, _mapOwn.mapOwn)(customAttributes, setCustom);
-      }
-      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.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((0, _config.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 = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(allCustomAttrs));
+    const aggregateHash = bucketHash + ':' + jsAttributesHash;
+    this.aggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs);
     function setCustom(key, val) {
-      customParams[key] = val && typeof val === 'object' ? (0, _stringify.stringify)(val) : val;
+      allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.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];
-      (0, _mapOwn.mapOwn)(globalCustomParams, setCustom);
-      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom);
-      (0, _mapOwn.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];
+      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom); // tack on custom attrs from the interaction
+      (0, _mapOwn.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 = (0, _stringHashCode.stringHashCode)((0, _stringify.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' ? (0, _stringify.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];
-      (0, _mapOwn.mapOwn)(globalCustomParams, setCustom);
-      (0, _mapOwn.mapOwn)(interaction.root.attrs.custom, setCustom);
-      (0, _mapOwn.mapOwn)(localCustomParams, setCustom);
-      var params = item[2];
       delete params._interactionId;
       delete params._interactionNodeId;
-      var hash = item[1];
-      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.stringify)(customParams));
+      var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1];
+      var jsAttributesHash = (0, _stringHashCode.stringHashCode)((0, _stringify.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' ? (0, _stringify.stringify)(val) : val;
+        allCustomAttrs[key] = val && typeof val === 'object' ? (0, _stringify.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
   }
 }
 exports.Aggregate = Aggregate;

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

@@ -15,35 +15,34 @@ var _load = require("../../../common/window/load");
 var _eventListenerOpts = require("../../../common/event-listener/event-listener-opts");
 var _runtime = require("../../../common/constants/runtime");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _drain = require("../../../common/drain/drain");
 class Aggregate extends _aggregateBase.AggregateBase {
   static featureName = _constants.FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
-    let scheduler;
-
-    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
-    (0, _registerHandler.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.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
+        (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
+      }
+    });
 
     // Allow features external to the metrics feature to capture SMs and CMs through the event emitter
     (0, _registerHandler.registerHandler)(_constants.SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee);
     (0, _registerHandler.registerHandler)(_constants.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.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;
@@ -67,6 +66,11 @@ class Aggregate extends _aggregateBase.AggregateBase {
       distMethod,
       loaderType
     } = (0, _config.getRuntime)(this.agentIdentifier);
+    const {
+      proxy,
+      privacy,
+      page_view_timing
+    } = (0, _config.getConfiguration)(this.agentIdentifier);
     if (loaderType) this.storeSupportabilityMetrics("Generic/LoaderType/".concat(loaderType, "/Detected"));
     if (distMethod) this.storeSupportabilityMetrics("Generic/DistMethod/".concat(distMethod, "/Detected"));
     if (_runtime.isBrowserScope) {
@@ -82,6 +86,8 @@ class Aggregate extends _aggregateBase.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 (_runtime.isWorkerScope) {
       this.storeSupportabilityMetrics('Generic/Runtime/Worker/Detected');
     } else {
@@ -100,13 +106,8 @@ class Aggregate extends _aggregateBase.AggregateBase {
     if (rules.length > 0 && !(0, _obfuscate.validateRules)(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid');
 
     // Check if proxy for either chunks or beacon is being used
-    const {
-      proxy,
-      privacy
-    } = (0, _config.getConfiguration)(this.agentIdentifier);
     if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed');
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed');
-    if (!(_runtime.isBrowserScope && privacy.cookies_enabled)) this.storeSupportabilityMetrics('Config/SessionTracking/Disabled');
   }
   eachSessionChecks() {
     if (!_runtime.isBrowserScope) return;

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

@@ -13,6 +13,7 @@ var _config = require("../../../common/config/config");
 var _constants = require("../constants");
 var _runtime = require("../../../common/constants/runtime");
 var _aggregateBase = require("../../utils/aggregate-base");
+var _drain = require("../../../common/drain/drain");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -37,8 +38,8 @@ class Aggregate extends _aggregateBase.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.HarvestScheduler('ins', {
           onFinished: function () {
             return _this.onHarvestFinished(...arguments);
@@ -48,11 +49,12 @@ class Aggregate extends _aggregateBase.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
+        (0, _drain.deregisterDrain)(this.agentIdentifier, this.featureName);
       }
     });
-    this.drain();
   }
   onHarvestStarted(options) {
     const {

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

@@ -17,6 +17,10 @@ var _aggregateBase = require("../../utils/aggregate-base");
 var _firstContentfulPaint = require("../../../common/vitals/first-contentful-paint");
 var _firstPaint = require("../../../common/vitals/first-paint");
 var _timeToFirstByte = require("../../../common/vitals/time-to-first-byte");
+var _drain = require("../../../common/drain/drain");
+var _features = require("../../../loaders/features/features");
+var _handle = require("../../../common/event-emitter/handle");
+var _constants2 = require("../../metrics/constants");
 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; }
 class Aggregate extends _aggregateBase.AggregateBase {
@@ -125,7 +129,9 @@ class Aggregate extends _aggregateBase.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
@@ -133,11 +139,25 @@ class Aggregate extends _aggregateBase.AggregateBase {
           return;
         }
         try {
-          (0, _featureFlags.activateFeatures)(JSON.parse(responseText), this.agentIdentifier);
+          this.timeKeeper.processRumRequest(xhr, fullUrl);
+        } catch (error) {
+          (0, _handle.handle)(_constants2.SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, _features.FEATURE_NAMES.metrics, this.ee);
+          (0, _drain.drain)(this.agentIdentifier, _features.FEATURE_NAMES.metrics, true);
+          this.ee.abort();
+          (0, _console.warn)('Could not calculate New Relic server time. Agent shutting down.');
+          return;
+        }
+        try {
+          const {
+            app,
+            ...flags
+          } = JSON.parse(responseText);
+          agentRuntime.appMetadata = app;
+          (0, _featureFlags.activateFeatures)(flags, this.agentIdentifier);
           this.drain();
         } catch (err) {
           this.ee.abort();
-          (0, _console.warn)('RUM call failed. Agent shutting down.');
+          (0, _console.warn)('RUM call failed. Agent shutting down.', err);
         }
       }
     });

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

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

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

@@ -43,17 +43,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     this.timings = [];
     this.timingsSent = [];
     this.curSessEndRecorded = false;
-    _firstPaint.firstPaint.subscribe(this.#handleVitalMetric);
-    _firstContentfulPaint.firstContentfulPaint.subscribe(this.#handleVitalMetric);
-    _firstInputDelay.firstInputDelay.subscribe(this.#handleVitalMetric);
-    _largestContentfulPaint.largestContentfulPaint.subscribe(this.#handleVitalMetric);
-    _interactionToNextPaint.interactionToNextPaint.subscribe(this.#handleVitalMetric);
-    _timeToFirstByte.timeToFirstByte.subscribe(_ref2 => {
-      let {
-        entries
-      } = _ref2;
-      this.addTiming('load', Math.round(entries[0].loadEventEnd));
-    });
     if ((0, _config.getConfigurationValue)(this.agentIdentifier, 'page_view_timing.long_task') === true) _longTask.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
@@ -63,9 +52,19 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)('winPagehide', msTimestamp => this.recordPageUnload(msTimestamp), this.featureName, this.ee);
     const initialHarvestSeconds = (0, _config.getConfigurationValue)(this.agentIdentifier, 'page_view_timing.initialHarvestSeconds') || 10;
     const harvestTimeSeconds = (0, _config.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.HarvestScheduler('events', {
+    this.waitForFlags([]).then(() => {
+      _firstPaint.firstPaint.subscribe(this.#handleVitalMetric);
+      _firstContentfulPaint.firstContentfulPaint.subscribe(this.#handleVitalMetric);
+      _firstInputDelay.firstInputDelay.subscribe(this.#handleVitalMetric);
+      _largestContentfulPaint.largestContentfulPaint.subscribe(this.#handleVitalMetric);
+      _interactionToNextPaint.interactionToNextPaint.subscribe(this.#handleVitalMetric);
+      _timeToFirstByte.timeToFirstByte.subscribe(_ref2 => {
+        let {
+          entries
+        } = _ref2;
+        this.addTiming('load', Math.round(entries[0].loadEventEnd));
+      });
+      const scheduler = new _harvestScheduler.HarvestScheduler('events', {
         onFinished: function () {
           return _this.onHarvestFinished(...arguments);
         },
@@ -73,9 +72,9 @@ class Aggregate extends _aggregateBase.AggregateBase {
           return _this.prepareHarvest(...arguments);
         }
       }, this);
-      this.scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds);
+      scheduler.startTimer(harvestTimeSeconds, initialHarvestSeconds);
+      this.drain();
     });
-    this.drain();
   }
 
   /**