@newrelic/browser-agent 1.253.0 → 1.254.0

package/src/common/event-emitter/contextual-ee.js

@@ -6,9 +6,11 @@
 import { gosNREUM } from '../window/nreum'
 import { getOrSet } from '../util/get-or-set'
 import { getRuntime } from '../config/config'
-import { EventContext } from '../context/event-context'
-import { ObservationContextManager } from '../context/observation-context-manager'
+import { EventContext } from './event-context'
+import { bundleId } from '../ids/bundle-id'
 
+// create a unique id to store event context data for the current agent bundle
+const contextId = `nr@context:${bundleId}`
 // create global emitter instance that can be shared among bundles
 const globalInstance = ee(undefined, 'globalEE')
 
@@ -18,7 +20,7 @@ if (!nr.ee) {
   nr.ee = globalInstance
 }
 
-export { globalInstance as ee }
+export { globalInstance as ee, contextId }
 
 function ee (old, debugId) {
   var handlers = {}
@@ -47,28 +49,41 @@ function ee (old, debugId) {
     context,
     buffer: bufferEventsByGroup,
     abort,
-    aborted: false,
     isBuffering,
     debugId,
     backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {},
-    observationContextManager: null
+    isolatedBacklog
   }
 
+  function abort () {
+    emitter._aborted = true
+    Object.keys(emitter.backlog).forEach(key => {
+      delete emitter.backlog[key]
+    })
+  }
+
+  Object.defineProperty(emitter, 'aborted', {
+    get: () => {
+      let aborted = emitter._aborted || false
+
+      if (aborted) return aborted
+      else if (old) {
+        aborted = old.aborted
+      }
+
+      return aborted
+    }
+  })
+
   return emitter
 
   function context (contextOrStore) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ObservationContextManager.contextId, () =>
-        emitter.observationContextManager
-          ? emitter.observationContextManager.getCreateContext(contextOrStore)
-          : new EventContext(ObservationContextManager.contextId)
-      )
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId))
     } else {
-      return emitter.observationContextManager
-        ? emitter.observationContextManager.getCreateContext({})
-        : new EventContext(ObservationContextManager.contextId)
+      return new EventContext(contextId)
     }
   }
 
@@ -116,13 +131,7 @@ function ee (old, debugId) {
   }
 
   function getOrCreate (name) {
-    const newEventEmitter = (emitters[name] = emitters[name] || ee(emitter, name))
-
-    if (!newEventEmitter.observationContextManager && emitter.observationContextManager) {
-      newEventEmitter.observationContextManager = emitter.observationContextManager
-    }
-
-    return newEventEmitter
+    return (emitters[name] = emitters[name] || ee(emitter, name))
   }
 
   function bufferEventsByGroup (types, group) {
@@ -151,14 +160,3 @@ function ee (old, debugId) {
     return emitter.backlog
   }
 }
-
-function abort () {
-  globalInstance.aborted = true
-  // The global backlog can be referenced directly by other emitters,
-  // so we need to delete its contents as opposed to replacing it.
-  // Otherwise, these references to the old backlog would still exist
-  // and the keys will not be garbage collected.
-  Object.keys(globalInstance.backlog).forEach(key => {
-    delete globalInstance.backlog[key]
-  })
-}

package/src/common/harvest/harvest.js

@@ -145,7 +145,7 @@ export class Harvest extends SharedContext {
       result.addEventListener('loadend', function () {
         // `this` refers to the XHR object in this scope, do not change this to a fat arrow
         // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
-        const cbResult = { sent: this.status !== 0, status: this.status }
+        const cbResult = { sent: this.status !== 0, status: this.status, xhr: this, fullUrl }
         if (this.status === 429) {
           cbResult.retry = true
           cbResult.delay = harvestScope.tooManyRequestsDelay
@@ -160,6 +160,9 @@ export class Harvest extends SharedContext {
       }, eventListenerOpts(false))
     }
 
+    const runtime = getRuntime(this.sharedContext.agentIdentifier)
+    runtime.harvestCount++
+
     return result
   }
 

package/src/common/timing/time-keeper.js

@@ -0,0 +1,96 @@
+import { gosNREUM } from '../window/nreum'
+import { globalScope } from '../constants/runtime'
+import { getRuntime } from '../config/config'
+
+/**
+ * Class used to adjust the timestamp of harvested data to New Relic server time. This
+ * is done by tracking the performance timings of the RUM call and applying a calculation
+ * to the harvested data event offset time.
+ */
+export class TimeKeeper {
+  #agent
+
+  /**
+   * Represents the browser origin time corrected to NR server time.
+   * @type {number}
+   */
+  #correctedOriginTime
+
+  /**
+   * Represents the difference in milliseconds between the calculated NR server time and
+   * the local time.
+   * @type {number}
+   */
+  #localTimeDiff
+
+  constructor (agent) {
+    this.#agent = agent
+  }
+
+  static getTimeKeeperByAgentIdentifier (agentIdentifier) {
+    const nr = gosNREUM()
+    return Object.keys(nr?.initializedAgents || {}).indexOf(agentIdentifier) > -1
+      ? nr.initializedAgents[agentIdentifier].timeKeeper
+      : undefined
+  }
+
+  get correctedPageOriginTime () {
+    return this.#correctedOriginTime
+  }
+
+  /**
+   * Process a rum request to calculate NR server time.
+   * @param rumRequest {XMLHttpRequest} The xhr for the rum request
+   * @param rumRequestUrl {string} The full url of the rum request
+   */
+  processRumRequest (rumRequest, rumRequestUrl) {
+    const responseDateHeader = rumRequest.getResponseHeader('Date')
+    if (!responseDateHeader) {
+      throw new Error('Missing date header on rum response.')
+    }
+
+    const resourceEntries = globalScope.performance.getEntriesByName(rumRequestUrl, 'resource')
+    if (!Array.isArray((resourceEntries)) || resourceEntries.length === 0) {
+      throw new Error('Missing rum request performance entry.')
+    }
+
+    let medianRumOffset = 0
+    let serverOffset = 0
+    if (typeof resourceEntries[0].responseStart === 'number' && resourceEntries[0].responseStart !== 0) {
+      // Cors is enabled and we can make a more accurate calculation of NR server time
+      medianRumOffset = (resourceEntries[0].responseStart - resourceEntries[0].requestStart) / 2
+      serverOffset = Math.floor(resourceEntries[0].requestStart + medianRumOffset)
+    } else {
+      // Cors is disabled or erred, we need to use a less accurate calculation
+      medianRumOffset = (resourceEntries[0].responseEnd - resourceEntries[0].fetchStart) / 2
+      serverOffset = Math.floor(resourceEntries[0].fetchStart + medianRumOffset)
+    }
+
+    // Corrected page origin time
+    this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset)
+    this.#localTimeDiff = getRuntime(this.#agent.agentIdentifier).offset - this.#correctedOriginTime
+
+    if (Number.isNaN(this.#correctedOriginTime)) {
+      throw new Error('Date header invalid format.')
+    }
+  }
+
+  /**
+   * Converts a page origin relative time to an absolute timestamp
+   * corrected to NR server time.
+   * @param relativeTime {number} The relative time of the event in milliseconds
+   * @returns {number} The correct timestamp as a unix/epoch timestamp value
+   */
+  convertRelativeTimestamp (relativeTime) {
+    return this.#correctedOriginTime + relativeTime
+  }
+
+  /**
+   * Corrects an event timestamp to NR server time.
+   * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
+   * @return {number} Corrected unix/epoch timestamp
+   */
+  correctAbsoluteTimestamp (timestamp) {
+    return Math.floor(timestamp - this.#localTimeDiff)
+  }
+}

package/src/common/util/feature-flags.js

@@ -3,49 +3,31 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ee } from '../event-emitter/contextual-ee'
-import { handle } from '../event-emitter/handle'
-import { FEATURE_NAMES } from '../../loaders/features/features'
 import { dispatchGlobalEvent } from '../dispatch/global-event'
 
-const bucketMap = {
-  stn: [FEATURE_NAMES.sessionTrace],
-  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
-  ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa, FEATURE_NAMES.softNav],
-  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
-}
-
 const sentIds = new Set()
 
-/** Note that this function only processes each unique flag ONCE, with the first occurrence of each flag and numeric value determining its switch on/off setting. */
+/** A map of feature flags and their values as provided by the rum call -- scoped by agent ID */
+export const activatedFeatures = {}
+
+/**
+ * Sets the activatedFeatures object, dispatches the global loaded event,
+ * and emits the rumresp flag to features
+ * @param {{[key:string]:number}} flags key-val pair of flag names and numeric
+ * @param {string} agentIdentifier agent instance identifier
+ * @returns {void}
+ */
 export function activateFeatures (flags, agentIdentifier) {
   const sharedEE = ee.get(agentIdentifier)
+  activatedFeatures[agentIdentifier] ??= {}
   if (!(flags && typeof flags === 'object')) return
   if (sentIds.has(agentIdentifier)) return
 
-  Object.entries(flags).forEach(([flag, num]) => {
-    if (bucketMap[flag]) {
-      bucketMap[flag].forEach(feat => {
-        if (!num) handle('block-' + flag, [], undefined, feat, sharedEE)
-        else handle('feat-' + flag, [], undefined, feat, sharedEE)
-        handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE) // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
-      })
-    } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE) // not sure what other flags are overlooked, but there's a test for ones not in the map --
-    activatedFeatures[flag] = Boolean(num)
-  })
+  sharedEE.emit('rumresp', [flags])
+  activatedFeatures[agentIdentifier] = flags
 
-  // Let the features waiting on their respective flags know that RUM response was received and that any missing flags are interpreted as bad entitlement / "off".
-  // Hence, those features will not be hanging forever if their flags aren't included in the response.
-  Object.keys(bucketMap).forEach(flag => {
-    if (activatedFeatures[flag] === undefined) {
-      bucketMap[flag]?.forEach(feat => handle('rumresp-' + flag, [false], undefined, feat, sharedEE))
-      activatedFeatures[flag] = false
-    }
-  })
   sentIds.add(agentIdentifier)
 
   // let any window level subscribers know that the agent is running
   dispatchGlobalEvent({ loaded: true })
 }
-
-export const activatedFeatures = {}

package/src/common/wrap/wrap-events.js

@@ -7,16 +7,16 @@
  * This module is used directly by: session_trace.
  * It is also called by -> wrapXhr <-, so see "wrap-xhr.js" for features that use this indirectly.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee'
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
 import { getOrSet } from '../util/get-or-set'
 import { globalScope, isBrowserScope } from '../constants/runtime'
-import { ObservationContextManager } from '../context/observation-context-manager'
 
 const wrapped = {}
 const XHR = globalScope.XMLHttpRequest
 const ADD_EVENT_LISTENER = 'addEventListener'
 const REMOVE_EVENT_LISTENER = 'removeEventListener'
+const flag = `nr@wrapped:${contextId}`
 
 /**
  * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
@@ -49,7 +49,7 @@ export function wrapEvents (sharedEE) {
       return
     }
 
-    var wrapped = getOrSet(originalListener, ObservationContextManager.contextWrappedId, function () {
+    var wrapped = getOrSet(originalListener, flag, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

package/src/common/wrap/wrap-fetch.js

@@ -6,9 +6,8 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee'
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
-import { ObservationContextManager } from '../context/observation-context-manager'
 
 var prefix = 'fetch-'
 var bodyPrefix = prefix + 'body-'
@@ -75,7 +74,7 @@ export function wrapFetch (sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx)
         var dtPayload
-        if (ctx[ObservationContextManager.contextId] && ctx[ObservationContextManager.contextId].dt) dtPayload = ctx[ObservationContextManager.contextId].dt
+        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt
 
         var origPromiseFromFetch = fn.apply(this, args)
 

package/src/common/wrap/wrap-function.js

@@ -7,7 +7,9 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-import { ObservationContextManager } from '../context/observation-context-manager'
+import { bundleId } from '../ids/bundle-id'
+
+export const flag = `nr@original:${bundleId}`
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -40,7 +42,7 @@ export function createWrapperWithEmitter (emitter, always) {
    * As a property on a wrapped function, contains the original function.
    * @type {string}
    */
-  wrapFn.flag = ObservationContextManager.contextOriginalId
+  wrapFn.flag = flag
 
   return wrapFn
 
@@ -59,7 +61,7 @@ export function createWrapperWithEmitter (emitter, always) {
 
     if (!prefix) prefix = ''
 
-    nrWrapper[ObservationContextManager.contextOriginalId] = fn
+    nrWrapper[flag] = fn
     copy(fn, nrWrapper, emitter)
     return nrWrapper
 
@@ -213,5 +215,5 @@ function copy (from, to, emitter) {
  * @returns {boolean} Whether the passed function is ineligible to be wrapped.
  */
 function notWrappable (fn) {
-  return !(fn && typeof fn === 'function' && fn.apply && !fn[ObservationContextManager.contextOriginalId])
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag])
 }

package/src/common/wrap/wrap-promise.js

@@ -7,10 +7,9 @@
  * This module is used by: spa.
  */
 
-import { createWrapperWithEmitter as wrapFn } from './wrap-function'
+import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function'
 import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
-import { ObservationContextManager } from '../context/observation-context-manager'
 
 const wrapped = {}
 
@@ -123,7 +122,7 @@ export function wrapPromise (sharedEE) {
 
       return origFnCallWithThis
     }
-    prevPromiseObj.prototype.then[ObservationContextManager.contextOriginalId] = prevPromiseOrigThen
+    prevPromiseObj.prototype.then[flag] = prevPromiseOrigThen
 
     promiseEE.on('executor-start', function (args) {
       args[0] = promiseWrapper(args[0], 'resolve-', this, null, false)

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

@@ -21,13 +21,17 @@ export class Aggregate extends AggregateBase {
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
     const agentInit = getConfiguration(agentIdentifier)
-    const allAjaxIsEnabled = agentInit.ajax.enabled !== false
 
     registerHandler('xhr', storeXhr, this.featureName, this.ee)
-    if (!allAjaxIsEnabled) {
+
+    this.waitForFlags(([])).then(() => {
+      const scheduler = new 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 = getRuntime(agentIdentifier).denyList
     setDenyList(denyList)
@@ -61,15 +65,6 @@ export class Aggregate extends AggregateBase {
     registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee)
     // --- ^
 
-    const scheduler = new HarvestScheduler('events', {
-      onFinished: onEventsHarvestFinished,
-      getPayload: prepareHarvest
-    }, this)
-
-    ee.on(`drain-${this.featureName}`, () => { scheduler.startTimer(harvestTimeSeconds) })
-
-    this.drain()
-
     const beacon = getInfo(agentIdentifier).errorBeacon
     const proxyBeacon = agentInit.proxy.beacon
 
@@ -92,8 +87,6 @@ export class Aggregate extends AggregateBase {
         aggregator.store('xhr', hash, params, metrics)
       }
 
-      if (!allAjaxIsEnabled) return
-
       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...
@@ -143,7 +136,6 @@ export class Aggregate extends AggregateBase {
       if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, ee)
 
       const softNavInUse = Boolean(getNREUMInitializedAgent(agentIdentifier)?.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
         handle('ajax', [event], undefined, 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

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

@@ -21,6 +21,7 @@ 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
@@ -48,21 +49,18 @@ export class Aggregate extends AggregateBase {
 
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10
 
-    const scheduler = new HarvestScheduler('jserrors', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
-    scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args))
-
-    // Don't start harvesting until "drain" for this feat has been called (which currently requires RUM response).
-    this.ee.on(`drain-${this.featureName}`, () => {
-      if (!this.blocked) scheduler.startTimer(harvestTimeSeconds) // and only if ingest will accept jserror payloads
+    // 0 == off, 1 == on
+    this.waitForFlags(['err']).then(([errFlag]) => {
+      if (errFlag) {
+        const scheduler = new HarvestScheduler('jserrors', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
+        scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args))
+        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) {

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

@@ -9,18 +9,25 @@ 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(([errFlag]) => {
+      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)
@@ -28,14 +35,6 @@ export class Aggregate extends AggregateBase {
 
     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-${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) {
@@ -55,6 +54,8 @@ export class Aggregate extends AggregateBase {
   singleChecks () {
     // report loaderType
     const { distMethod, loaderType } = getRuntime(this.agentIdentifier)
+    const { proxy, privacy, page_view_timing } = getConfiguration(this.agentIdentifier)
+
     if (loaderType) this.storeSupportabilityMetrics(`Generic/LoaderType/${loaderType}/Detected`)
     if (distMethod) this.storeSupportabilityMetrics(`Generic/DistMethod/${distMethod}/Detected`)
 
@@ -72,6 +73,9 @@ 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 {
@@ -90,11 +94,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 () {

package/src/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
@@ -31,17 +32,17 @@ export class Aggregate extends AggregateBase {
 
     register('api-addPageAction', (...args) => this.addPageAction(...args), this.featureName, this.ee)
 
-    this.waitForFlags(['ins']).then(([enabled]) => {
-      if (enabled) {
+    this.waitForFlags(['ins']).then(([insFlag]) => {
+      if (insFlag) {
         const scheduler = new HarvestScheduler('ins', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
         scheduler.harvest.on('ins', (...args) => this.onHarvestStarted(...args))
         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) {

package/src/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
@@ -100,7 +104,7 @@ export class Aggregate extends AggregateBase {
       endpoint: 'rum',
       payload: { qs: queryParameters, body },
       opts: { needResponse: true, sendEmptyBody: true },
-      cbFinished: ({ status, responseText }) => {
+      cbFinished: ({ status, responseText, xhr, fullUrl }) => {
         if (status >= 400 || status === 0) {
           // Adding retry logic for the rum call will be a separate change
           this.ee.abort()
@@ -108,7 +112,19 @@ export class Aggregate extends AggregateBase {
         }
 
         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()