@newrelic/browser-agent 1.269.0 → 1.270.1

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

@@ -1,5 +1,3 @@
-import { getConfigurationValue } from '../../../common/config/init'
-import { deregisterDrain } from '../../../common/drain/drain'
 import { handle } from '../../../common/event-emitter/handle'
 import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
@@ -16,14 +14,14 @@ import { Interaction } from './interaction'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
-  constructor (agentIdentifier, aggregator, { domObserver }) {
-    super(agentIdentifier, aggregator, FEATURE_NAME)
+  constructor (agentRef, { domObserver }) {
+    super(agentRef, FEATURE_NAME)
 
-    const harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'soft_navigations.harvestTimeSeconds') || 10
+    const harvestTimeSeconds = agentRef.init.soft_navigations.harvestTimeSeconds || 10
     this.interactionsToHarvest = new EventBuffer()
     this.domObserver = domObserver
 
-    this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentIdentifier)
+    this.initialPageLoadInteraction = new InitialPageLoadInteraction(agentRef.agentIdentifier)
     timeToFirstByte.subscribe(({ attrs }) => {
       const loadEventTime = attrs.navigationEntry.loadEventEnd
       this.initialPageLoadInteraction.forceSave = true
@@ -45,12 +43,12 @@ export class Aggregate extends AggregateBase {
           onFinished: this.onHarvestFinished.bind(this),
           retryDelay: harvestTimeSeconds,
           onUnload: () => this.interactionInProgress?.done() // return any held ajax or jserr events so they can be sent with EoL harvest
-        }, { agentIdentifier, ee: this.ee })
+        }, this)
         scheduler.harvest.on('events', this.onHarvestStarted.bind(this))
         scheduler.startTimer(harvestTimeSeconds, 0)
       } 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)
+        this.deregisterDrain()
       }
     })
 

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

@@ -18,8 +18,8 @@ const UI_WAIT_INTERVAL = 1 / 10 * 1000 // assume 10 fps
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
-  constructor (agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto)
+  constructor (agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto)
     if (!isBrowserScope || !gosNREUMOriginals().o.MO) return // soft navigations is not supported outside web env or browsers without the mutation observer API
 
     const historyEE = wrapHistory(this.ee)
@@ -58,7 +58,7 @@ export class Instrument extends InstrumentBase {
     for (let eventType of INTERACTION_TRIGGERS) document.addEventListener(eventType, () => { /* no-op, this ensures the UI events are monitored by our callback above */ })
 
     this.abortHandler = abort
-    this.importAggregator({ domObserver })
+    this.importAggregator(agentRef, { domObserver })
 
     function abort () {
       this.removeOnAbort?.abort()

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

@@ -9,8 +9,6 @@ import { shouldCollectEvent } from '../../../common/deny-list/deny-list'
 import { navTimingValues as navTiming } from '../../../common/timing/nav-timing'
 import { generateUuid } from '../../../common/ids/unique-id'
 import { Interaction } from './interaction'
-import { getConfigurationValue } from '../../../common/config/init'
-import { getRuntime } from '../../../common/config/runtime'
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { Serializer } from './serializer'
@@ -24,7 +22,6 @@ import { bundleId } from '../../../common/ids/bundle-id'
 import { loadedAsDeferredBrowserScript } from '../../../common/constants/runtime'
 import { handle } from '../../../common/event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
-import { deregisterDrain } from '../../../common/drain/drain'
 import { warn } from '../../../common/util/console'
 import { EventBuffer } from '../../utils/event-buffer'
 
@@ -34,13 +31,12 @@ const {
 } = CONSTANTS
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
-  constructor (agentIdentifier, aggregator) {
-    super(agentIdentifier, aggregator, FEATURE_NAME)
+  constructor (agentRef) {
+    super(agentRef, FEATURE_NAME)
 
-    const agentRuntime = getRuntime(agentIdentifier)
     this.state = {
-      initialPageURL: agentRuntime.origin,
-      lastSeenUrl: agentRuntime.origin,
+      initialPageURL: agentRef.runtime.origin,
+      lastSeenUrl: agentRef.runtime.origin,
       lastSeenRouteName: null,
       timerMap: {},
       timerBudget: MAX_TIMER_BUDGET,
@@ -51,10 +47,10 @@ export class Aggregate extends AggregateBase {
       pageLoaded: false,
       childTime: 0,
       depth: 0,
-      harvestTimeSeconds: getConfigurationValue(agentIdentifier, 'spa.harvestTimeSeconds') || 10,
+      harvestTimeSeconds: agentRef.init.spa.harvestTimeSeconds || 10,
       interactionsToHarvest: new EventBuffer(),
       // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
-      disableSpaFix: (getConfigurationValue(agentIdentifier, 'feature_flags') || []).indexOf('disable-spa-fix') > -1
+      disableSpaFix: (agentRef.init.feature_flags || []).indexOf('disable-spa-fix') > -1
     }
 
     let scheduler
@@ -62,7 +58,7 @@ export class Aggregate extends AggregateBase {
 
     const { state, serializer } = this
 
-    const baseEE = ee.get(agentIdentifier) // <-- parent baseEE
+    const baseEE = ee.get(agentRef.agentIdentifier) // <-- parent baseEE
     const mutationEE = baseEE.get('mutation')
     const promiseEE = baseEE.get('promise')
     const historyEE = baseEE.get('history')
@@ -110,18 +106,18 @@ export class Aggregate extends AggregateBase {
         scheduler = new HarvestScheduler('events', {
           onFinished: onHarvestFinished,
           retryDelay: state.harvestTimeSeconds
-        }, { agentIdentifier, ee: baseEE })
+        }, this)
         scheduler.harvest.on('events', onHarvestStarted)
         this.drain()
       } else {
         this.blocked = true
-        deregisterDrain(this.agentIdentifier, this.featureName)
+        this.deregisterDrain()
       }
     })
 
-    if (!isEnabled()) return
+    if (agentRef.init.spa.enabled !== true) return
 
-    state.initialPageLoad = new Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier)
+    state.initialPageLoad = new Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier)
     state.initialPageLoad.save = true
     state.prevInteraction = state.initialPageLoad
     state.currentNode = state.initialPageLoad.root // hint
@@ -212,7 +208,7 @@ export class Aggregate extends AggregateBase {
         // Otherwise, if no interaction is currently active, create a new node ID,
         // and let the aggregator know that we entered a new event handler callback
         // so that it has a chance to possibly start an interaction.
-        var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier)
+        var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier)
 
         // Store the interaction as prevInteraction in case it is prematurely discarded
         state.prevInteraction = ixn
@@ -310,7 +306,7 @@ export class Aggregate extends AggregateBase {
         this.sent = true
         node.dt = this.dt
         if (node.dt?.timestamp) {
-          node.dt.timestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(node.dt.timestamp)
+          node.dt.timestamp = agentRef.runtime.timeKeeper.correctAbsoluteTimestamp(node.dt.timestamp)
         }
         node.jsEnd = node.start = this.startTime
         node[INTERACTION][REMAINING]++
@@ -410,7 +406,7 @@ export class Aggregate extends AggregateBase {
           if (dtPayload && this[SPA_NODE]) {
             this[SPA_NODE].dt = dtPayload
             if (this[SPA_NODE].dt?.timestamp) {
-              this[SPA_NODE].dt.timestamp = agentRuntime.timeKeeper.correctAbsoluteTimestamp(this[SPA_NODE].dt.timestamp)
+              this[SPA_NODE].dt.timestamp = agentRef.runtime.timeKeeper.correctAbsoluteTimestamp(this[SPA_NODE].dt.timestamp)
             }
           }
         }
@@ -548,7 +544,7 @@ export class Aggregate extends AggregateBase {
       var interaction
       if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION]
       else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName !== 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION]
-      else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier)
+      else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentRef.agentIdentifier)
       if (!state.currentNode) {
         interaction.checkFinish()
         if (state.depth) setCurrentNode(interaction.root)
@@ -702,9 +698,9 @@ export class Aggregate extends AggregateBase {
     register('function-err', function (args, obj, error) {
       if (!state.currentNode) return
       error.__newrelic ??= {}
-      error.__newrelic[agentIdentifier] = { interactionId: state.currentNode.interaction.id }
+      error.__newrelic[agentRef.agentIdentifier] = { interactionId: state.currentNode.interaction.id }
       if (state.currentNode.type && state.currentNode.type !== 'interaction') {
-        error.__newrelic[agentIdentifier].interactionNodeId = state.currentNode.id
+        error.__newrelic[agentRef.agentIdentifier].interactionNodeId = state.currentNode.id
       }
     }, this.featureName, baseEE)
 
@@ -751,10 +747,5 @@ export class Aggregate extends AggregateBase {
       scheduler?.scheduleHarvest(0)
       if (!scheduler) warn(19)
     }
-
-    function isEnabled () {
-      var enabled = getConfigurationValue(agentIdentifier, 'spa.enabled')
-      return enabled !== false
-    }
   }
 }

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

@@ -25,8 +25,8 @@ const {
  */
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
-  constructor (agentIdentifier, aggregator, auto = true) {
-    super(agentIdentifier, aggregator, FEATURE_NAME, auto)
+  constructor (agentRef, auto = true) {
+    super(agentRef, FEATURE_NAME, auto)
     if (!isBrowserScope) return // SPA not supported outside web env
 
     try {
@@ -54,7 +54,7 @@ export class Instrument extends InstrumentBase {
     promiseEE.on(CB_END, endTimestamp)
     jsonpEE.on(CB_END, endTimestamp)
 
-    this.ee.on('fn-err', (...args) => { if (!args[2]?.__newrelic?.[agentIdentifier]) handle('function-err', [...args], undefined, this.featureName, this.ee) })
+    this.ee.on('fn-err', (...args) => { if (!args[2]?.__newrelic?.[agentRef.agentIdentifier]) handle('function-err', [...args], undefined, this.featureName, this.ee) })
 
     this.ee.buffer([FN_START, FN_END, 'xhr-resolved'], this.featureName)
     eventsEE.buffer([FN_START], this.featureName)
@@ -110,7 +110,7 @@ export class Instrument extends InstrumentBase {
     }
 
     this.abortHandler = this.#abort
-    this.importAggregator()
+    this.importAggregator(agentRef)
   }
 
   /** Restoration and resource release tasks to be done if SPA loader is being aborted. Unwind changes to globals and subscription to DOM events. */

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

@@ -1,6 +1,5 @@
-export const FeatureBase = jest.fn(function (agentIdentifier, aggregator, featureName) {
+export const FeatureBase = jest.fn(function (agentIdentifier, featureName) {
   this.agentIdentifier = agentIdentifier
-  this.aggregator = aggregator
   this.featureName = featureName
 
   this.ee = {

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

@@ -1,17 +1,17 @@
 import { FeatureBase } from './feature-base'
-import { getInfo, isValid } from '../../common/config/info'
-import { getRuntime } from '../../common/config/runtime'
+import { isValid } from '../../common/config/info'
 import { configure } from '../../loaders/configure/configure'
 import { gosCDN } from '../../common/window/nreum'
-import { deregisterDrain, drain } from '../../common/drain/drain'
+import { drain } from '../../common/drain/drain'
 import { activatedFeatures } from '../../common/util/feature-flags'
 import { Obfuscator } from '../../common/util/obfuscate'
 
 export class AggregateBase extends FeatureBase {
-  constructor (...args) {
-    super(...args)
-    this.checkConfiguration()
-    this.obfuscator = getRuntime(this.agentIdentifier).obfuscator
+  constructor (agentRef, featureName) {
+    super(agentRef.agentIdentifier, featureName)
+    this.agentRef = agentRef
+    this.checkConfiguration(agentRef)
+    this.obfuscator = agentRef.runtime.obfuscator
   }
 
   /**
@@ -38,7 +38,7 @@ export class AggregateBase extends FeatureBase {
     return flagsPromise.catch(err => {
       this.ee.emit('internal-error', [err])
       this.blocked = true
-      deregisterDrain(this.agentIdentifier, this.featureName)
+      this.deregisterDrain()
     })
   }
 
@@ -51,7 +51,7 @@ export class AggregateBase extends FeatureBase {
    * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
    * loader configurations may appear after the loader code is executed.
    */
-  checkConfiguration () {
+  checkConfiguration (existingAgent) {
     // NOTE: This check has to happen at aggregator load time
     if (!isValid(this.agentIdentifier)) {
       const cdn = gosCDN()
@@ -59,7 +59,7 @@ export class AggregateBase extends FeatureBase {
       try {
         jsAttributes = {
           ...jsAttributes,
-          ...getInfo(this.agentIdentifier)?.jsAttributes
+          ...existingAgent.info?.jsAttributes
         }
       } catch (err) {
         // do nothing
@@ -70,13 +70,12 @@ export class AggregateBase extends FeatureBase {
           ...cdn.info,
           jsAttributes
         },
-        runtime: getRuntime(this.agentIdentifier)
+        runtime: existingAgent.runtime
       })
     }
 
-    const runtime = getRuntime(this.agentIdentifier)
-    if (!runtime.obfuscator) {
-      runtime.obfuscator = new Obfuscator(this.agentIdentifier)
+    if (!existingAgent.runtime.obfuscator) {
+      existingAgent.runtime.obfuscator = new Obfuscator(this.agentIdentifier)
     }
   }
 }

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

@@ -1,11 +1,10 @@
 import { ee } from '../../common/event-emitter/contextual-ee'
+import { deregisterDrain } from '../../common/drain/drain'
 
 export class FeatureBase {
-  constructor (agentIdentifier, aggregator, featureName) {
+  constructor (agentIdentifier, featureName) {
     /** @type {string} */
     this.agentIdentifier = agentIdentifier
-    /** @type {import('../../common/aggregate/aggregator').Aggregator} */
-    this.aggregator = aggregator
     /** @type {import('../../common/event-emitter/contextual-ee').ee} */
     this.ee = ee.get(agentIdentifier)
     /** @type {string} */
@@ -17,4 +16,8 @@ export class FeatureBase {
      */
     this.blocked = false
   }
+
+  deregisterDrain () {
+    deregisterDrain(this.agentIdentifier, this.featureName)
+  }
 }

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

@@ -10,7 +10,6 @@ import { onWindowLoad } from '../../common/window/load'
 import { isBrowserScope } from '../../common/constants/runtime'
 import { warn } from '../../common/util/console'
 import { FEATURE_NAMES } from '../../loaders/features/features'
-import { getConfigurationValue } from '../../common/config/init'
 import { hasReplayPrerequisite } from '../session_replay/shared/utils'
 import { canEnableSessionTracking } from './feature-gates'
 import { single } from '../../common/util/invoke'
@@ -23,14 +22,13 @@ export class InstrumentBase extends FeatureBase {
   /**
    * Instantiate InstrumentBase.
    * @param {string} agentIdentifier - The unique ID of the instantiated agent (relative to global scope).
-   * @param {import('../../common/aggregate/aggregator').Aggregator} aggregator - The shared Aggregator that will handle batching and reporting of data.
    * @param {string} featureName - The name of the feature module (used to construct file path).
    * @param {boolean} [auto=true] - Determines whether the feature should automatically register to have the draining
    *     of its pooled instrumentation data handled by the agent's centralized drain functionality, rather than draining
    *     immediately. Primarily useful for fine-grained control in tests.
    */
-  constructor (agentIdentifier, aggregator, featureName, auto = true) {
-    super(agentIdentifier, aggregator, featureName)
+  constructor (agentRef, featureName, auto = true) {
+    super(agentRef.agentIdentifier, featureName)
     this.auto = auto
 
     /** @type {Function | undefined} This should be set by any derived Instrument class if it has things to do when feature fails or is killed. */
@@ -50,16 +48,16 @@ export class InstrumentBase extends FeatureBase {
     this.onAggregateImported = undefined
 
     /** used in conjunction with newrelic.start() to defer harvesting in features */
-    if (getConfigurationValue(this.agentIdentifier, `${this.featureName}.autoStart`) === false) this.auto = false
+    if (agentRef.init[this.featureName].autoStart === false) this.auto = false
     /** if the feature requires opt-in (!auto-start), it will get registered once the api has been called */
-    if (this.auto) registerDrain(agentIdentifier, featureName)
+    if (this.auto) registerDrain(agentRef.agentIdentifier, featureName)
     else {
       this.ee.on('manual-start-all', single(() => {
         // register the feature to drain only once the API has been called, it will drain when importAggregator finishes for all the features
         // called by the api in that cycle
-        registerDrain(this.agentIdentifier, this.featureName)
+        registerDrain(agentRef.agentIdentifier, this.featureName)
         this.auto = true
-        this.importAggregator()
+        this.importAggregator(agentRef)
       }))
     }
   }
@@ -67,10 +65,11 @@ export class InstrumentBase extends FeatureBase {
   /**
    * Lazy-load the latter part of the feature: its aggregator. This method is called by the first part of the feature
    * (the instrumentation) when instrumentation is complete.
+   * @param agentRef - reference to the base agent ancestor that this feature belongs to
    * @param {Object} [argsObjFromInstrument] - any values or references to pass down to aggregate
    * @returns void
    */
-  importAggregator (argsObjFromInstrument = {}) {
+  importAggregator (agentRef, argsObjFromInstrument = {}) {
     if (this.featAggregate || !this.auto) return
 
     let loadedSuccessfully
@@ -91,6 +90,13 @@ export class InstrumentBase extends FeatureBase {
         if (this.featureName === FEATURE_NAMES.sessionReplay) this.abortHandler?.() // SR should stop recording if session DNE
       }
 
+      // Create a single Aggregator for this agent if DNE yet; to be used by jserror endpoint features.
+      if (!agentRef.sharedAggregator) {
+        agentRef.sharedAggregator = import(/* webpackChunkName: "shared-aggregator" */ '../../common/aggregate/aggregator')
+        const { Aggregator } = await agentRef.sharedAggregator
+        agentRef.sharedAggregator = new Aggregator()
+      } else await agentRef.sharedAggregator // if another feature is already importing the aggregator, wait for it to finish
+
       /**
        * Note this try-catch differs from the one in Agent.run() in that it's placed later in a page's lifecycle and
        * it's only responsible for aborting its one specific feature, rather than all.
@@ -103,7 +109,7 @@ export class InstrumentBase extends FeatureBase {
         }
         const { lazyFeatureLoader } = await import(/* webpackChunkName: "lazy-feature-loader" */ './lazy-feature-loader')
         const { Aggregate } = await lazyFeatureLoader(this.featureName, 'aggregate')
-        this.featAggregate = new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument)
+        this.featAggregate = new Aggregate(agentRef, argsObjFromInstrument)
         loadedSuccessfully(true)
       } catch (e) {
         warn(34, e)

package/src/loaders/agent.js

@@ -10,7 +10,6 @@ import { featurePriority, FEATURE_NAMES } from './features/features'
 // required features
 import { Instrument as PageViewEvent } from '../features/page_view_event/instrument'
 // common files
-import { Aggregator } from '../common/aggregate/aggregator'
 import { gosNREUM, setNREUMInitializedAgent } from '../common/window/nreum'
 import { warn } from '../common/util/console'
 import { globalScope } from '../common/constants/runtime'
@@ -34,7 +33,6 @@ export class Agent extends AgentBase {
       return
     }
 
-    this.sharedAggregator = new Aggregator({ agentIdentifier: this.agentIdentifier })
     this.features = {}
     setNREUMInitializedAgent(this.agentIdentifier, this) // append this agent onto the global NREUM.initializedAgents
 
@@ -80,7 +78,7 @@ export class Agent extends AgentBase {
           })
         }
 
-        this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator)
+        this.features[InstrumentCtor.featureName] = new InstrumentCtor(this)
       })
     } catch (err) {
       warn(22, err)

package/src/loaders/micro-agent.js

@@ -3,7 +3,6 @@ import { Instrument as PVE } from '../features/page_view_event/instrument'
 import { getEnabledFeatures } from './features/enabled-features'
 import { configure } from './configure/configure'
 // core files
-import { Aggregator } from '../common/aggregate/aggregator'
 import { setNREUMInitializedAgent } from '../common/window/nreum'
 import { getInfo } from '../common/config/info'
 import { getConfiguration, getConfigurationValue } from '../common/config/init'
@@ -11,7 +10,6 @@ import { getLoaderConfig } from '../common/config/loader-config'
 import { getRuntime } from '../common/config/runtime'
 import { FEATURE_NAMES } from './features/features'
 import { warn } from '../common/util/console'
-import { onWindowLoad } from '../common/window/load'
 import { AgentBase } from './agent-base'
 
 const nonAutoFeatures = [
@@ -34,7 +32,6 @@ export class MicroAgent extends AgentBase {
   constructor (options, agentIdentifier) {
     super(agentIdentifier)
 
-    this.sharedAggregator = new Aggregator({ agentIdentifier: this.agentIdentifier })
     this.features = {}
     setNREUMInitializedAgent(this.agentIdentifier, this)
 
@@ -77,21 +74,22 @@ export class MicroAgent extends AgentBase {
 
       try {
         // a biproduct of doing this is that the "session manager" is automatically handled through importing this feature
-        this.features.page_view_event = new PVE(this.agentIdentifier, this.sharedAggregator)
+        this.features.page_view_event = new PVE(this)
       } catch (err) {
         warn(24, err)
       }
 
-      onWindowLoad(() => {
-        // these features do not import an "instrument" file, meaning they are only hooked up to the API.
+      this.features.page_view_event.onAggregateImported.then(() => {
+        /* The following features do not import an "instrument" file, meaning they are only hooked up to the API.
+        Since the missing instrument-base class handles drain-gating (racing behavior) and PVE handles some setup, these are chained until after PVE has finished initializing
+        so as to avoid the race condition of things like session and sharedAggregator not being ready by features that uses them right away. */
         nonAutoFeatures.forEach(f => {
           if (enabledFeatures[f] && features.includes(f)) {
             import(/* webpackChunkName: "lazy-feature-loader" */ '../features/utils/lazy-feature-loader').then(({ lazyFeatureLoader }) => {
               return lazyFeatureLoader(f, 'aggregate')
             }).then(({ Aggregate }) => {
-              this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator)
-            }).catch(err =>
-              warn(25, err))
+              this.features[f] = new Aggregate(this)
+            }).catch(err => warn(25, err))
           }
         })
       })