@newrelic/browser-agent 0.1.230 → 1.232.0

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

@@ -1,17 +1,19 @@
-import { getRuntime } from '../../../common/config/config'
+import { getRuntime, getInfo } from '../../../common/config/config'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
-import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { getFrameworks } from '../../../common/metrics/framework-detection'
-import { protocol } from '../../../common/url/protocol'
+import { isFileProtocol } from '../../../common/url/protocol'
 import { getRules, validateRules } from '../../../common/util/obfuscate'
-import { VERSION } from '../../../common/constants/environment-variables'
+import { VERSION } from '../../../common/constants/env'
 import { onDOMContentLoaded } from '../../../common/window/load'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { isBrowserScope } from '../../../common/util/global-scope'
-export class Aggregate extends AggregateBase {
+import { FeatureBase } from '../../utils/feature-base'
+import { stringify } from '../../../common/util/stringify'
+
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -70,9 +72,8 @@ export class Aggregate extends AggregateBase {
     }
 
     // file protocol detection
-    if (protocol.isFileProtocol()) {
+    if (isFileProtocol()) {
       this.storeSupportabilityMetrics('Generic/FileProtocol/Detected')
-      protocol.supportabilityMetricSent = true
     }
 
     // obfuscation rules detection
@@ -97,6 +98,7 @@ export class Aggregate extends AggregateBase {
     try {
       if (this.resourcesSent) return
       const agentRuntime = getRuntime(this.agentIdentifier)
+      const info = getInfo(this.agentIdentifier)
       // make sure this only gets sent once
       this.resourcesSent = true
       // differentiate between internal+external and ajax+non-ajax
@@ -123,10 +125,22 @@ export class Aggregate extends AggregateBase {
         )
       })
 
+      // Capture per-agent query bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
+      Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
+        this.storeSupportabilityMetrics(
+          `PageSession/Endpoint/${endpoint.charAt(0).toUpperCase() + endpoint.slice(1)}/QueryBytesSent`,
+          agentRuntime.queryBytesSent[endpoint]
+        )
+      })
+
       // Capture metrics for session trace if active (`ptid` is set when returned by replay ingest).
       if (agentRuntime.ptid) {
         this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()))
       }
+
+      // Capture metrics for size of custom attributes
+      const jsAttributes = stringify(info.jsAttributes)
+      this.storeSupportabilityMetrics('PageSession/Feature/CustomData/Bytes', jsAttributes === '{}' ? 0 : jsAttributes.length)
     } catch (e) {
       // do nothing
     }

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

@@ -3,42 +3,12 @@ import { insertSupportMetrics } from './workers-helper'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants'
 import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { wrapConsole } from '../../../common/wrap'
-import { stringify } from '../../../common/util/stringify'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
     insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee))
-
-    this.addConsoleSupportabilityMetrics()
-
     this.importAggregator()
   }
-
-  addConsoleSupportabilityMetrics () {
-    // For now we are just capturing supportability metrics on `console` usage to assess log forwarding feature.
-    const consoleEE = wrapConsole(this.ee)
-
-    for (const method of ['Debug', 'Error', 'Info', 'Log', 'Trace', 'Warn']) {
-      consoleEE.on(`${method.toLowerCase()}-console-start`, function (args, target) {
-        // Parsing the args individually into a new array ensures that functions and Error objects are represented with
-        // useful string values. By default, functions stringify to null and Error objects stringify to empty objects.
-        // Note that stack traces printed by the console.trace method are not captured.
-        let parsedArgs = []
-        for (const arg of args) {
-          if (typeof arg === 'function' ||
-            (arg && arg.message && arg.stack) // Duck typing for Error objects
-          ) {
-            parsedArgs.push(arg.toString())
-          } else {
-            parsedArgs.push(arg)
-          }
-        }
-        const parsedArgsJSON = stringify(parsedArgs)
-        handle(SUPPORTABILITY_METRIC_CHANNEL, [`Console/${method}/Seen`, parsedArgsJSON.length], undefined, FEATURE_NAMES.metrics, consoleEE)
-      })
-    }
-  }
 }

package/src/features/metrics/instrument/workers-helper.js

@@ -37,23 +37,26 @@ export function insertSupportMetrics (report) {
     return // similarly, if dedicated is n/a, none of them are supported so quit
   } else {
     origWorker = Worker
-    try { globalScope.Worker = extendWorkerConstructor(origWorker, 'Dedicated') }
-    catch (e) { handleInsertionError(e, 'Dedicated') }
+    try {
+      globalScope.Worker = extendWorkerConstructor(origWorker, 'Dedicated')
+    } catch (e) { handleInsertionError(e, 'Dedicated') }
   }
 
   if (!workersApiIsSupported.shared) {
     reportUnavailable('Shared')
   } else {
     origSharedWorker = SharedWorker
-    try { globalScope.SharedWorker = extendWorkerConstructor(origSharedWorker, 'Shared') }
-    catch (e) { handleInsertionError(e, 'Shared') }
+    try {
+      globalScope.SharedWorker = extendWorkerConstructor(origSharedWorker, 'Shared')
+    } catch (e) { handleInsertionError(e, 'Shared') }
   }
   if (!workersApiIsSupported.service) {
     reportUnavailable('Service')
   } else {
     origServiceWorkerCreate = navigator.serviceWorker.register
-    try { globalScope.navigator.serviceWorker.register = extendServiceCreation(origServiceWorkerCreate) }
-    catch (e) { handleInsertionError(e, 'Service') }
+    try {
+      globalScope.navigator.serviceWorker.register = extendServiceCreation(origServiceWorkerCreate)
+    } catch (e) { handleInsertionError(e, 'Service') }
   }
   return
 

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

@@ -9,12 +9,12 @@ import { registerHandler as register } from '../../../common/event-emitter/regis
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { cleanURL } from '../../../common/url/clean-url'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
-import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { isBrowserScope } from '../../../common/util/global-scope'
+import { FeatureBase } from '../../utils/feature-base'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)

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

@@ -10,15 +10,15 @@ import { paintMetrics } from '../../../common/metrics/paint-metrics'
 import { submitData } from '../../../common/util/submit-data'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
-import { AggregateBase } from '../../utils/aggregate-base'
 import * as CONSTANTS from '../constants'
 import { getActivatedFeaturesFlags } from './initialized-features'
 import { globalScope, isBrowserScope } from '../../../common/util/global-scope'
 import { drain } from '../../../common/drain/drain'
+import { FeatureBase } from '../../utils/feature-base'
 
 const jsonp = 'NREUM.setToken'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = CONSTANTS.FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME)
@@ -89,12 +89,21 @@ export class Aggregate extends AggregateBase {
     chunksForQueryString.push(param('pr', info.product))
     chunksForQueryString.push(param('af', getActivatedFeaturesFlags(this.agentIdentifier).join(',')))
 
-    if (globalScope.performance && typeof (globalScope.performance.timing) !== 'undefined') {
-      var navTimingApiData = ({
-        timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}),
-        navigation: addPN(globalScope.performance.navigation, {})
-      })
-      chunksForQueryString.push(param('perf', stringify(navTimingApiData)))
+    if (globalScope.performance) {
+      if (typeof PerformanceNavigationTiming !== 'undefined') { // Navigation Timing level 2 API that replaced PerformanceTiming & PerformanceNavigation
+        const navTimingEntry = globalScope?.performance?.getEntriesByType('navigation')?.[0]
+        const perf = ({
+          timing: addPT(agentRuntime.offset, navTimingEntry, {}),
+          navigation: addPN(navTimingEntry, {})
+        })
+        chunksForQueryString.push(param('perf', stringify(perf)))
+      } else if (typeof PerformanceTiming !== 'undefined') { // Safari pre-15 did not support level 2 timing
+        const perf = ({
+          timing: addPT(agentRuntime.offset, globalScope.performance.timing, {}, true),
+          navigation: addPN(globalScope.performance.navigation, {})
+        })
+        chunksForQueryString.push(param('perf', stringify(perf)))
+      }
     }
 
     try { // PVTiming sends these too, albeit using web-vitals and slightly different; it's unknown why they're duplicated, but PVT should be the truth
@@ -121,7 +130,10 @@ export class Aggregate extends AggregateBase {
     var queryString = fromArray(chunksForQueryString, agentRuntime.maxBytes)
 
     // Capture bytes sent to RUM call endpoint (currently `1`) as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.bytesSent[protocol] = (agentRuntime.bytesSent[protocol] || 0) + queryString?.length || 0
+    agentRuntime.bytesSent[protocol] = 0 // Set to zero for now until RUM is moved to POST
+
+    // Capture query bytes sent to RUM call endpoint (currently `1`) as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.queryBytesSent[protocol] = (agentRuntime.queryBytesSent[protocol] || 0) + queryString?.length || 0
 
     const isValidJsonp = submitData.jsonp(
       this.getScheme() + '://' + info.beacon + '/' + protocol + '/' + info.licenseKey + queryString,

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

@@ -14,12 +14,12 @@ import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { cleanURL } from '../../../common/url/clean-url'
 import { handle } from '../../../common/event-emitter/handle'
 import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config'
-import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { FeatureBase } from '../../utils/feature-base'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -27,13 +27,9 @@ export class Aggregate extends AggregateBase {
     this.timings = []
     this.timingsSent = []
     this.curSessEndRecorded = false
+    this.cls = null // this should be null unless set to a numeric value by web-vitals so that we differentiate if CLS is supported
 
-    try { // we (only) need to track cls state because it's attached to other timing events rather than reported on change...
-      this.clsSupported = PerformanceObserver.supportedEntryTypes.includes('layout-shift')
-      this.cls = 0
-    } catch (e) {}
-
-    /*! This is the section that used to be in the loader portion: !*/
+    /* ! This is the section that used to be in the loader portion: ! */
     /* ------------------------------------------------------------ */
     const pageStartedHidden = getRuntime(agentIdentifier).initHidden // our attempt at recapturing initial vis state since this code runs post-load time
     this.alreadySent = new Set() // since we don't support timings on BFCache restores, this tracks and helps cap metrics that web-vitals report more than once
@@ -66,7 +62,7 @@ export class Aggregate extends AggregateBase {
 
     /* First Input Delay (+"First Interaction") - As of WV v3, it still imperfectly tries to detect document vis state asap and isn't supposed to report if page starts hidden. */
     onFID(({ name, value, entries }) => {
-      if (pageStartedHidden || this.alreadySent.has(name)) return
+      if (pageStartedHidden || this.alreadySent.has(name) || entries.length === 0) return
       this.alreadySent.add(name)
 
       // CWV will only report one (THE) first-input entry to us; fid isn't reported if there are no user interactions occurs before the *first* page hiding.
@@ -84,24 +80,28 @@ export class Aggregate extends AggregateBase {
       if (pageStartedHidden || this.alreadySent.has(name)) return
       this.alreadySent.add(name)
 
-      // CWV will only ever report one (THE) lcp entry to us; lcp is also only reported *once* on earlier(user interaction, page hidden).
-      const lcpEntry = entries[entries.length - 1] // this looks weird if we only expect one, but this is how cwv-attribution gets it so to be sure...
-      const attrs = {
-        size: lcpEntry.size,
-        eid: lcpEntry.id
-      }
-      this.addConnectionAttributes(attrs)
-      if (lcpEntry.url) {
-        attrs['elUrl'] = cleanURL(lcpEntry.url)
-      }
-      if (lcpEntry.element && lcpEntry.element.tagName) {
-        attrs['elTag'] = lcpEntry.element.tagName
+      const attributes = {}
+      if (entries.length > 0) {
+        // CWV will only ever report one (THE) lcp entry to us; lcp is also only reported *once* on earlier(user interaction, page hidden).
+        const lcpEntry = entries[entries.length - 1] // this looks weird if we only expect one, but this is how cwv-attribution gets it so to be sure...
+        attributes.size = lcpEntry.size
+        attributes.eid = lcpEntry.id
+
+        if (lcpEntry.url) {
+          attributes.elUrl = cleanURL(lcpEntry.url)
+        }
+        if (lcpEntry.element?.tagName) {
+          attributes.elTag = lcpEntry.element.tagName
+        }
       }
-      this.addTiming(name.toLowerCase(), value, attrs)
+
+      this.addConnectionAttributes(attributes)
+      this.addTiming(name.toLowerCase(), value, attributes)
     })
 
-    /* Cumulative Layout Shift - We don't have to limit this callback since cls is stored as a state and only sent as attribute on other timings. */
-    onCLS(({ value }) => this.cls = value)
+    /* Cumulative Layout Shift - We don't have to limit this callback since cls is stored as a state and only sent as attribute on other timings.
+      reportAllChanges ensures our tracked cls has the most recent rolling value to attach to 'unload' and 'pagehide'. */
+    onCLS(({ value }) => this.cls = value, { reportAllChanges: true })
 
     /* Interaction-to-Next-Paint */
     onINP(({ name, value, id }) => this.addTiming(name.toLowerCase(), value, { metricId: id }))
@@ -160,17 +160,28 @@ export class Aggregate extends AggregateBase {
    */
   recordPageUnload (timestamp) {
     this.addTiming('unload', timestamp, null)
-    // Because window's pageHide commonly fires before vis change and the final harvest occurs on the earlier of the two, we also have to add that now or it won't make it into the last payload out.
+    /*
+    Issue: Because window's pageHide commonly fires BEFORE vis change and "final" harvest would happen at the former in this case, we also have to add our vis-change event now or it may not be sent.
+    Affected: Safari < v14.1/.5 ; versions that don't support 'visiilitychange' event
+    Impact: For affected w/o this, NR 'pageHide' attribute may not be sent. For other browsers w/o this, NR 'pageHide' gets fragmented into its own harvest call on page unloading because of dual EoL logic.
+    Mitigation: NR 'unload' and 'pageHide' are both recorded when window pageHide fires, rather than only recording 'unload'.
+    Future: When EoL can become the singular subscribeToVisibilityChange, it's likely endCurrentSession isn't needed here as 'unload'-'pageHide' can be untangled.
+    */
     this.endCurrentSession(timestamp)
   }
 
   addTiming (name, value, attrs) {
     attrs = attrs || {}
 
-    // If CLS is supported, a cls value should exist and be reported, even at 0.
-    // *cli Mar'23 - At this time, it remains attached to all timings. See NEWRELIC-6143.
-    if (this.clsSupported) {
-      attrs['cls'] = this.cls
+    // If cls was set to another value by `onCLS`, then it's supported and is attached onto any timing but is omitted until such time.
+    /*
+    *cli Apr'23 - Convert attach-to-all -> attach-if-not-null. See NEWRELIC-6143.
+    Issue: Because NR 'pageHide' was only sent once with what is considered the "final" CLS value, in the case that 'pageHide' fires before 'load' happens, we incorrectly a final CLS of 0 for that page.
+    Mitigation: We've set initial CLS to null so that it's omitted from timings like 'pageHide' in that edge case. It should only be included if onCLS callback was executed at least once.
+    Future: onCLS value changes should be reported directly & CLS separated into its own timing node so it's not beholden to 'pageHide' firing. It'd also be possible to report the real final CLS.
+    */
+    if (this.cls !== null) {
+      attrs.cls = this.cls
     }
 
     this.timings.push({

package/src/features/page_view_timing/long-tasks.js

@@ -15,21 +15,21 @@ export const onLongTask = (onReport) => {
       const metric = {
         name: 'LT',
         value: entry.duration,
-        info: {	// this property deviates from CWV std interface but will hold the custom context to send to NRDB
-          ltFrame: entry.name,				// MDN: the browsing context or frame that can be attributed to the long task
-          ltStart: entry.startTime,	// MDN: a double representing the time (millisec) when the task started
-          ltCtr: entry.attribution[0].containerType			// MDN: type of frame container: 'iframe', 'embed', or 'object' ... but this can also be 'window'
+        info: { // this property deviates from CWV std interface but will hold the custom context to send to NRDB
+          ltFrame: entry.name, // MDN: the browsing context or frame that can be attributed to the long task
+          ltStart: entry.startTime, // MDN: a double representing the time (millisec) when the task started
+          ltCtr: entry.attribution[0].containerType // MDN: type of frame container: 'iframe', 'embed', or 'object' ... but this can also be 'window'
         }
       }
-      if (metric.info.ltCtr !== 'window') {	// the following properties are only of relevance & appended for html elements
+      if (metric.info.ltCtr !== 'window') { // the following properties are only of relevance & appended for html elements
         Object.assign(metric.info, {
-          ltCtrSrc: entry.attribution[0].containerSrc,		// MDN: container's 'src' attribute
-          ltCtrId: entry.attribution[0].containerId,			// MDN: container's 'id' attribute
-          ltCtrName: entry.attribution[0].containerName		// MDN: container's 'name' attribute
+          ltCtrSrc: entry.attribution[0].containerSrc, // MDN: container's 'src' attribute
+          ltCtrId: entry.attribution[0].containerId, // MDN: container's 'id' attribute
+          ltCtrName: entry.attribution[0].containerName // MDN: container's 'name' attribute
         })
       }
 
-      onReport(metric)	// report every long task observed unconditionally
+      onReport(metric) // report every long task observed unconditionally
     })
   }
 
@@ -53,7 +53,7 @@ export const onLongTask = (onReport) => {
   if (observer) {
     subscribeToEOL(() => {
       handleEntries(observer.takeRecords())
-    }, true)	// this bool is a temp arg under staged BFCache work that runs the func under the new page session logic -- tb removed w/ the feature flag later
+    }, true) // this bool is a temp arg under staged BFCache work that runs the func under the new page session logic -- tb removed w/ the feature flag later
 
     /* No work needed on BFCache restore for long task. */
   }

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

@@ -11,12 +11,12 @@ import { supportsPerformanceObserver } from '../../../common/window/supports-per
 import slice from 'lodash._slice'
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config'
 import { now } from '../../../common/timing/now'
-import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { HandlerCache } from '../../utils/handler-cache'
+import { FeatureBase } from '../../utils/feature-base'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -75,7 +75,11 @@ export class Aggregate extends AggregateBase {
     this.laststart = 0
 
     registerHandler('feat-stn', () => {
-      this.storeTiming(window.performance.timing)
+      if (typeof PerformanceNavigationTiming !== 'undefined') {
+        this.storeTiming(window.performance?.getEntriesByType('navigation')?.[0] || {})
+      } else {
+        this.storeTiming(window.performance?.timing)
+      }
 
       var scheduler = new HarvestScheduler('resources', {
         onFinished: onHarvestFinished.bind(this),
@@ -135,25 +139,24 @@ export class Aggregate extends AggregateBase {
   processPVT (name, value, attrs) {
     var t = {}
     t[name] = value
-    this.storeTiming(t, true)
+    this.storeTiming(t)
     if (this.hasFID(name, attrs)) this.storeEvent({ type: 'fid', target: 'document' }, 'document', value, value + attrs.fid)
   }
 
-  storeTiming (_t, ignoreOffset) {
-    var key
-    var val
-    var timeOffset
-    var dateNow = Date.now()
-
+  storeTiming (_t) {
     // loop iterates through prototype also (for FF)
-    for (key in _t) {
-      val = _t[key]
+    for (let key in _t) {
+      const val = _t[key]
+
+      // ignore size and status type nodes that do not map to timestamp metrics
+      const lck = key.toLowerCase()
+      if (lck.indexOf('size') >= 0 || lck.indexOf('status') >= 0) continue
 
       // ignore inherited methods, meaningless 0 values, and bogus timestamps
       // that are in the future (Microsoft Edge seems to sometimes produce these)
-      if (!(typeof (val) === 'number' && val > 0 && val < dateNow)) continue
+      if (!(typeof (val) === 'number' && val >= 0)) continue
 
-      timeOffset = !ignoreOffset ? _t[key] - getRuntime(this.agentIdentifier).offset : _t[key]
+      const timeOffset = Math.round(_t[key])
 
       this.storeSTN({
         n: key,

package/src/features/session_trace/instrument/index.js

@@ -78,8 +78,9 @@ export class Instrument extends InstrumentBase {
       observeResourceTimings()
     } else {
       // collect resource timings once when buffer is full
-      if (window.performance[CRT] && window.performance[ADD_EVENT_LISTENER])
-      { window.performance.addEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, eventListenerOpts(false)) }
+      if (window.performance[CRT] && window.performance[ADD_EVENT_LISTENER]) {
+        window.performance.addEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, eventListenerOpts(false))
+      }
     }
 
     function observeResourceTimings () {

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

@@ -2,7 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-/*eslint no-undef: "error"*/
+/* eslint no-undef: "error" */
 import { registerHandler as register } from '../../../common/event-emitter/register-handler'
 import { parseUrl } from '../../../common/url/parse-url'
 import { shouldCollectEvent } from '../../../common/deny-list/deny-list'
@@ -13,19 +13,19 @@ import { paintMetrics } from '../../../common/metrics/paint-metrics'
 import { Interaction } from './interaction'
 import { getConfigurationValue, getRuntime } from '../../../common/config/config'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
-import { AggregateBase } from '../../utils/aggregate-base'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { Serializer } from './serializer'
 import { ee } from '../../../common/event-emitter/contextual-ee'
 import * as CONSTANTS from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { FeatureBase } from '../../utils/feature-base'
 
 const {
   FEATURE_NAME, INTERACTION_EVENTS, MAX_TIMER_BUDGET, FN_START, FN_END, CB_START, INTERACTION_API, REMAINING,
   INTERACTION, SPA_NODE, JSONP_NODE, FETCH_START, FETCH_DONE, FETCH_BODY, JSONP_END, originalSetTimeout
 } = CONSTANTS
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -67,7 +67,7 @@ export class Aggregate extends AggregateBase {
     const scheduler = new HarvestScheduler('events', {
       onFinished: onHarvestFinished,
       retryDelay: state.harvestTimeSeconds
-    }, { agentIdentifier })
+    }, { agentIdentifier, ee: baseEE })
     scheduler.harvest.on('events', onHarvestStarted)
 
     // childTime is used when calculating exclusive time for a cb duration.
@@ -212,7 +212,7 @@ export class Aggregate extends AggregateBase {
           if (evName === 'click') {
             var value = getActionText(ev.target)
             if (value) {
-              state.currentNode.attrs.custom['actionText'] = value
+              state.currentNode.attrs.custom.actionText = value
             }
           }
         }

package/src/features/spa/instrument/index.js

@@ -24,8 +24,10 @@ export class Instrument extends InstrumentBase {
 
     if (!getRuntime(agentIdentifier).xhrWrappable) return
 
-    try { this.removeOnAbort = new AbortController() }
-    catch (e) {}
+    try {
+      this.removeOnAbort = new AbortController()
+    } catch (e) {}
+
     let depth = 0
     let startHash
 

package/src/features/utils/agent-session.js

@@ -0,0 +1,68 @@
+import { getConfigurationValue, getInfo, getRuntime, setInfo } from '../../common/config/config'
+import { drain } from '../../common/drain/drain'
+import { ee } from '../../common/event-emitter/contextual-ee'
+import { registerHandler } from '../../common/event-emitter/register-handler'
+import { isBrowserScope } from '../../common/util/global-scope'
+import { SessionEntity } from '../../common/session/session-entity'
+import { LocalStorage } from '../../common/storage/local-storage.js'
+import { FirstPartyCookies } from '../../common/storage/first-party-cookies'
+import { LocalMemory } from '../../common/storage/local-memory'
+
+let ranOnce = 0
+export function setupAgentSession (agentIdentifier) {
+  const agentRuntime = getRuntime(agentIdentifier)
+  if (ranOnce++) return agentRuntime.session
+
+  const sharedEE = ee.get(agentIdentifier)
+
+  // domain is a string that can be specified by customer.
+  // only way to keep the session object across subdomains is using first party cookies
+  // This determines which storage wrapper the session manager will use to keep state
+  let storageAPI
+  const cookiesEnabled = getConfigurationValue(agentIdentifier, 'privacy.cookies_enabled') === true
+  if (cookiesEnabled && isBrowserScope) {
+    storageAPI = getConfigurationValue(agentIdentifier, 'session.domain')
+      ? new FirstPartyCookies(getConfigurationValue(agentIdentifier, 'session.domain'))
+      : new LocalStorage()
+  }
+
+  if (cookiesEnabled) {
+    // defaults to "LocalMemory" if storageAPI is undefined, such as in Worker build
+    agentRuntime.session = new SessionEntity({
+      agentIdentifier,
+      key: 'SESSION',
+      storageAPI,
+      expiresMs: getConfigurationValue(agentIdentifier, 'session.expiresMs'),
+      inactiveMs: getConfigurationValue(agentIdentifier, 'session.inactiveMs')
+    })
+  }
+
+  // The first time the agent runs on a page, it should put everything
+  // that's currently stored in the storage API into the local info.jsAttributes object
+  if (isBrowserScope) {
+    // retrieve & re-add all of the persisted setCustomAttribute|setUserId k-v from previous page load(s)
+    const customSessionData = agentRuntime.session?.read?.()?.custom
+    const agentInfo = getInfo(agentIdentifier)
+    if (customSessionData) {
+      setInfo(agentIdentifier, { ...agentInfo, jsAttributes: { ...agentInfo.jsAttributes, ...customSessionData } })
+    }
+  }
+
+  // any calls to newrelic.setCustomAttribute(<persisted>) will need to be added to:
+  // local info.jsAttributes {}
+  // the session's storage API
+  registerHandler('api-setCustomAttribute', (time, key, value) => {
+    agentRuntime.session.syncCustomAttribute(key, value)
+  }, 'session', sharedEE)
+
+  // any calls to newrelic.setUserId(...) will need to be added to:
+  // local info.jsAttributes {}
+  // the session's storage API
+  registerHandler('api-setUserId', (time, key, value) => {
+    agentRuntime.session.syncCustomAttribute(key, value)
+  }, 'session', sharedEE)
+
+  drain(agentIdentifier, 'session')
+
+  return agentRuntime.session
+}

package/src/features/utils/feature-base.js

@@ -28,7 +28,7 @@ export class FeatureBase {
    * loader configurations may appear after the loader code is executed.
    */
   checkConfiguration () {
-    // NOTE: This check has to happen at aggregator load time, but could be moved to `AggregateBase`.
+    // NOTE: This check has to happen at aggregator load time
     if (!isConfigured(this.agentIdentifier)) {
       let jsAttributes = { ...gosCDN().info?.jsAttributes }
       try {

package/src/features/utils/instrument-base.js

@@ -49,13 +49,16 @@ export class InstrumentBase extends FeatureBase {
        * it's only responsible for aborting its one specific feature, rather than all.
        */
       try {
+        // The session entity needs to be attached to the config internals before the aggregator chunk runs
+        const { setupAgentSession } = await import(/* webpackChunkName: "session-manager" */ './agent-session')
+        setupAgentSession(this.agentIdentifier)
+        // import and instantiate the aggregator chunk
         const { lazyLoader } = await import(/* webpackChunkName: "lazy-loader" */ './lazy-loader')
         const { Aggregate } = await lazyLoader(this.featureName, 'aggregate')
         new Aggregate(this.agentIdentifier, this.aggregator)
       } catch (e) {
-        warn(`Downloading ${this.featureName} failed...`)
+        warn(`Downloading ${this.featureName} failed...`, e)
         this.abortHandler?.() // undo any important alterations made to the page
-
         // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
       }
     }

package/src/features/utils/lazy-loader.js

@@ -9,7 +9,7 @@ import { FEATURE_NAMES } from '../../loaders/features/features'
  * should be.
  * @param featureName Name of the feature to import such as ajax or session_trace
  * @param featurePart Name of the feature part to load; should be either instrument or aggregate
- * @returns {Promise<InstrumentBase|AggregateBase|null>}
+ * @returns {Promise<InstrumentBase|FeatureBase|null>}
  */
 export function lazyLoader (featureName, featurePart) {
   if (featurePart === 'aggregate') {

package/src/loaders/agent.js

@@ -68,7 +68,7 @@ export class Agent {
       }
 
       const newrelic = gosNREUM()
-      delete newrelic.initializedAgents[this.agentIdentifier]?.['api'] // prevent further calls to agent-specific APIs (see "configure.js")
+      delete newrelic.initializedAgents[this.agentIdentifier]?.api // prevent further calls to agent-specific APIs (see "configure.js")
       delete newrelic.initializedAgents[this.agentIdentifier]?.[NR_FEATURES_REF_NAME] // GC mem used internally by features
       delete this.sharedAggregator
       // Keep the initialized agent object with its configs for troubleshooting purposes.