@newrelic/browser-agent 1.232.1 → 1.233.0

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

@@ -20,13 +20,13 @@ import { globalScope } from '../../../common/util/global-scope'
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { FeatureBase } from '../../utils/feature-base'
+import { AggregateBase } from '../../utils/aggregate-base'
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
  */
 
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -189,10 +189,12 @@ export class Aggregate extends FeatureBase {
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time: time }
 
-    // stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
     // and spa annotates the error with interaction info
-    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.sessionTrace, this.ee)
-    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.spa, this.ee)
+    const msg = [type, bucketHash, params, newMetrics]
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee)
+    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionReplay, this.ee)
 
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return

package/src/features/metrics/aggregate/framework-detection.js

@@ -0,0 +1,73 @@
+import { isBrowserScope } from '../../../common/util/global-scope'
+
+const FRAMEWORKS = {
+  REACT: 'React',
+  ANGULAR: 'Angular',
+  ANGULARJS: 'AngularJS',
+  BACKBONE: 'Backbone',
+  EMBER: 'Ember',
+  VUE: 'Vue',
+  METEOR: 'Meteor',
+  ZEPTO: 'Zepto',
+  JQUERY: 'Jquery',
+  MOOTOOLS: 'MooTools'
+}
+
+export function getFrameworks () {
+  if (!isBrowserScope) return [] // don't bother detecting frameworks if not in the main window context
+
+  const frameworks = []
+  try {
+    if (detectReact()) frameworks.push(FRAMEWORKS.REACT)
+    if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS)
+    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR)
+    if (Object.prototype.hasOwnProperty.call(window, 'Backbone')) frameworks.push(FRAMEWORKS.BACKBONE)
+    if (Object.prototype.hasOwnProperty.call(window, 'Ember')) frameworks.push(FRAMEWORKS.EMBER)
+    if (Object.prototype.hasOwnProperty.call(window, 'Vue')) frameworks.push(FRAMEWORKS.VUE)
+    if (Object.prototype.hasOwnProperty.call(window, 'Meteor')) frameworks.push(FRAMEWORKS.METEOR)
+    if (Object.prototype.hasOwnProperty.call(window, 'Zepto')) frameworks.push(FRAMEWORKS.ZEPTO)
+    if (Object.prototype.hasOwnProperty.call(window, 'jQuery')) frameworks.push(FRAMEWORKS.JQUERY)
+    if (Object.prototype.hasOwnProperty.call(window, 'MooTools')) frameworks.push(FRAMEWORKS.MOOTOOLS)
+  } catch (err) {
+    // Possibly not supported
+  }
+  return frameworks
+}
+
+function detectReact () {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'React') ||
+      Object.prototype.hasOwnProperty.call(window, 'ReactDOM') ||
+      Object.prototype.hasOwnProperty.call(window, 'ReactRedux') ||
+      document.querySelector('[data-reactroot], [data-reactid]') ||
+      (() => {
+        const divs = document.querySelectorAll('body > div')
+        for (let i = 0; i < divs.length; i++) {
+          if (Object.prototype.hasOwnProperty.call(divs[i], '_reactRootContainer')) {
+            return true
+          }
+        }
+      })()
+  } catch (err) {
+    return false
+  }
+}
+
+function detectAngularJs () {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'angular') ||
+      document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]') ||
+      document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]')
+  } catch (err) {
+    return false
+  }
+}
+
+function detectAngular () {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, 'ng') ||
+      document.querySelector('[ng-version]')
+  } catch (err) {
+    return false
+  }
+}

package/src/features/metrics/aggregate/framework-detection.test.js

@@ -0,0 +1,201 @@
+import { faker } from '@faker-js/faker'
+import { getFrameworks } from './framework-detection'
+
+jest.mock('../../../common/util/global-scope', () => ({
+  isBrowserScope: true
+}))
+
+afterEach(() => {
+  document.body.innerHTML = ''
+})
+
+test('framework detection should not happen in non-browser scope', async () => {
+  global.React = {}
+
+  jest.resetModules()
+  jest.doMock('../../../common/util/global-scope', () => ({
+    isBrowserScope: false
+  }))
+  const frameworkDetector = await import('./framework-detection')
+
+  expect(frameworkDetector.getFrameworks()).toEqual([])
+
+  delete global.React
+})
+
+test('should detect react from global React property', () => {
+  global.React = {}
+
+  expect(getFrameworks()).toEqual(['React'])
+
+  delete global.React
+})
+
+test('should detect react from global ReactDOM property', () => {
+  global.ReactDOM = {}
+
+  expect(getFrameworks()).toEqual(['React'])
+
+  delete global.ReactDOM
+})
+
+test('should detect react from global ReactRedux property', () => {
+  global.ReactRedux = {}
+
+  expect(getFrameworks()).toEqual(['React'])
+
+  delete global.ReactRedux
+})
+
+test('should detect react from html [data-reactroot] property', () => {
+  document.body.innerHTML = '<div data-reactroot=""></div>'
+
+  expect(getFrameworks()).toEqual(['React'])
+})
+
+test('should detect react from html [data-reactid] property', () => {
+  document.body.innerHTML = '<div data-reactid=""></div>'
+
+  expect(getFrameworks()).toEqual(['React'])
+})
+
+test('should detect react from element _reactRootContainer property', () => {
+  const element = document.createElement('div')
+  element._reactRootContainer = {}
+  document.body.innerHTML = '<html><body></body></html>'
+  document.body.appendChild(element)
+
+  expect(getFrameworks()).toEqual(['React'])
+})
+
+test('should detect angularjs from global angular property', () => {
+  global.angular = {}
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+
+  delete global.angular
+})
+
+test('should detect angularjs from html .ng-binding property', () => {
+  document.body.innerHTML = '<div class="ng-binding"></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from html [ng-app] property', () => {
+  document.body.innerHTML = '<div ng-app=""></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from html [data-ng-app] property', () => {
+  document.body.innerHTML = '<div data-ng-app=""></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from html [ng-controller] property', () => {
+  document.body.innerHTML = '<div ng-controller=""></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from html [data-ng-controller] property', () => {
+  document.body.innerHTML = '<div data-ng-controller=""></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from html [ng-repeat] property', () => {
+  document.body.innerHTML = '<div ng-repeat=""></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from html [data-ng-repeat] property', () => {
+  document.body.innerHTML = '<div data-ng-repeat=""></div>'
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from angular.js script element', () => {
+  document.body.innerHTML = `<script src="${faker.internet.url()}/angular.js"></script>`
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angularjs from angular.min.js script element', () => {
+  document.body.innerHTML = `<script src="${faker.internet.url()}/angular.min.js"></script>`
+
+  expect(getFrameworks()).toEqual(['AngularJS'])
+})
+
+test('should detect angular from global ng property', () => {
+  global.ng = {}
+
+  expect(getFrameworks()).toEqual(['Angular'])
+
+  delete global.ng
+})
+
+test('should detect angular from html [ng-version] property', () => {
+  document.body.innerHTML = '<div ng-version=""></div>'
+
+  expect(getFrameworks()).toEqual(['Angular'])
+})
+
+test('should detect backbone from global Backbone property', () => {
+  global.Backbone = {}
+
+  expect(getFrameworks()).toEqual(['Backbone'])
+
+  delete global.Backbone
+})
+
+test('should detect ember from global Ember property', () => {
+  global.Ember = {}
+
+  expect(getFrameworks()).toEqual(['Ember'])
+
+  delete global.Ember
+})
+
+test('should detect vue from global Vue property', () => {
+  global.Vue = {}
+
+  expect(getFrameworks()).toEqual(['Vue'])
+
+  delete global.Vue
+})
+
+test('should detect meteor from global Meteor property', () => {
+  global.Meteor = {}
+
+  expect(getFrameworks()).toEqual(['Meteor'])
+
+  delete global.Meteor
+})
+
+test('should detect zepto from global Zepto property', () => {
+  global.Zepto = {}
+
+  expect(getFrameworks()).toEqual(['Zepto'])
+
+  delete global.Zepto
+})
+
+test('should detect jquery from global jQuery property', () => {
+  global.jQuery = {}
+
+  expect(getFrameworks()).toEqual(['Jquery'])
+
+  delete global.jQuery
+})
+
+test('should detect mootools from global MooTools property', () => {
+  global.MooTools = {}
+
+  expect(getFrameworks()).toEqual(['MooTools'])
+
+  delete global.MooTools
+})

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

@@ -3,17 +3,18 @@ import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 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 { getFrameworks } from './framework-detection'
+import { getPolyfills } from './polyfill-detection'
 import { isFileProtocol } from '../../../common/url/protocol'
 import { getRules, validateRules } from '../../../common/util/obfuscate'
 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'
-import { FeatureBase } from '../../utils/feature-base'
+import { AggregateBase } from '../../utils/aggregate-base'
 import { stringify } from '../../../common/util/stringify'
 
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
@@ -71,6 +72,10 @@ export class Aggregate extends FeatureBase {
       })
     }
 
+    getPolyfills().forEach(polyfill => {
+      this.storeSupportabilityMetrics('Polyfill/' + polyfill + '/Detected')
+    })
+
     // file protocol detection
     if (isFileProtocol()) {
       this.storeSupportabilityMetrics('Generic/FileProtocol/Detected')

package/src/features/metrics/aggregate/polyfill-detection.es5.js

@@ -0,0 +1,9 @@
+
+/**
+ * This file is used as a replacement for the polyfill-detection.es5.js
+ * file when running the polyfills webpack build.
+ * @returns {string[]} an empty array
+ */
+export function getPolyfills () {
+  return []
+}

package/src/features/metrics/aggregate/polyfill-detection.es5.test.js

@@ -0,0 +1,16 @@
+import { getPolyfills } from './polyfill-detection.es5'
+
+afterEach(() => {
+  jest.resetAllMocks()
+})
+
+test('should always return an empty array', () => {
+  const originalFn = Array.from
+  Array.from = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual([])
+
+  Array.from = originalFn
+})

package/src/features/metrics/aggregate/polyfill-detection.js

@@ -0,0 +1,48 @@
+const detectionRegex = /\{ \[native code\] \}/
+const POLYFILLS = {
+  FUNCTION_BIND: 'Function.bind',
+  FUNCTION_APPLY: 'Function.apply',
+  FUNCTION_CALL: 'Function.call',
+  ARRAY_INCLUDES: 'Array.includes',
+  ARRAY_FROM: 'Array.from',
+  ARRAY_FIND: 'Array.find',
+  ARRAY_FLAT: 'Array.flat',
+  ARRAY_FLATMAP: 'Array.flatMap',
+  OBJECT_ASSIGN: 'Object.assign',
+  OBJECT_ENTRIES: 'Object.entries',
+  OBJECT_VALUES: 'Object.values',
+  MAP: 'Map',
+  SET: 'Set',
+  WEAK_MAP: 'WeakMap',
+  WEAK_SET: 'WeakSet'
+}
+
+/**
+ * Checks for native globals to see if they have been polyfilled by customer code.
+ * @returns {string[]} Array of methods that were detected to have been polyfilled
+ */
+export function getPolyfills () {
+  const polyfills = []
+  const mockFunction = function () { /* noop */ }
+  try {
+    if (typeof mockFunction.bind === 'function' && !detectionRegex.test(mockFunction.bind.toString())) polyfills.push(POLYFILLS.FUNCTION_BIND)
+    if (typeof mockFunction.apply === 'function' && !detectionRegex.test(mockFunction.apply.toString())) polyfills.push(POLYFILLS.FUNCTION_APPLY)
+    if (typeof mockFunction.call === 'function' && !detectionRegex.test(mockFunction.call.toString())) polyfills.push(POLYFILLS.FUNCTION_CALL)
+    if (typeof [].includes === 'function' && !detectionRegex.test([].includes.toString())) polyfills.push(POLYFILLS.ARRAY_INCLUDES)
+    if (typeof Array.from === 'function' && !detectionRegex.test(Array.from.toString())) polyfills.push(POLYFILLS.ARRAY_FROM)
+    if (typeof [].find === 'function' && !detectionRegex.test([].find.toString())) polyfills.push(POLYFILLS.ARRAY_FIND)
+    if (typeof [].flat === 'function' && !detectionRegex.test([].flat.toString())) polyfills.push(POLYFILLS.ARRAY_FLAT)
+    if (typeof [].flatMap === 'function' && !detectionRegex.test([].flatMap.toString())) polyfills.push(POLYFILLS.ARRAY_FLATMAP)
+    if (typeof Object.assign === 'function' && !detectionRegex.test(Object.assign.toString())) polyfills.push(POLYFILLS.OBJECT_ASSIGN)
+    if (typeof Object.entries === 'function' && !detectionRegex.test(Object.entries.toString())) polyfills.push(POLYFILLS.OBJECT_ENTRIES)
+    if (typeof Object.values === 'function' && !detectionRegex.test(Object.values.toString())) polyfills.push(POLYFILLS.OBJECT_VALUES)
+    if (typeof Map === 'function' && !detectionRegex.test(Map.toString())) polyfills.push(POLYFILLS.MAP)
+    if (typeof Set === 'function' && !detectionRegex.test(Set.toString())) polyfills.push(POLYFILLS.SET)
+    if (typeof WeakMap === 'function' && !detectionRegex.test(WeakMap.toString())) polyfills.push(POLYFILLS.WEAK_MAP)
+    if (typeof WeakSet === 'function' && !detectionRegex.test(WeakSet.toString())) polyfills.push(POLYFILLS.WEAK_SET)
+  } catch (err) {
+    // Possibly not supported
+  }
+
+  return polyfills
+}

package/src/features/metrics/aggregate/polyfill-detection.test.js

@@ -0,0 +1,163 @@
+/* eslint-disable no-global-assign */
+/* eslint-disable no-extend-native */
+import { getPolyfills } from './polyfill-detection'
+
+// DO NOT test Function.prototype.apply, it causes recursion in Jest
+
+test('should return an empty array when nothing is polyfilled', () => {
+  expect(getPolyfills()).toEqual([])
+})
+
+test('should indicate Function.prototype.bind is polyfilled', () => {
+  const originalFn = Function.prototype.bind
+  Function.prototype.bind = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Function.bind'])
+
+  Function.prototype.bind = originalFn
+})
+
+test('should indicate Function.prototype.call is polyfilled', () => {
+  const originalFn = Function.prototype.call
+  Function.prototype.call = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Function.call'])
+
+  Function.prototype.call = originalFn
+})
+
+test('should indicate Array.prototype.includes is polyfilled', () => {
+  const originalFn = Array.prototype.includes
+  Array.prototype.includes = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Array.includes'])
+
+  Array.prototype.includes = originalFn
+})
+
+test('should indicate Array.from is polyfilled', () => {
+  const originalFn = Array.from
+  Array.from = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Array.from'])
+
+  Array.from = originalFn
+})
+
+test('should indicate Array.prototype.find is polyfilled', () => {
+  const originalFn = Array.prototype.find
+  Array.prototype.find = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Array.find'])
+
+  Array.prototype.find = originalFn
+})
+
+test('should indicate Array.prototype.flat is polyfilled', () => {
+  const originalFn = Array.prototype.flat
+  Array.prototype.flat = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Array.flat'])
+
+  Array.prototype.flat = originalFn
+})
+
+test('should indicate Array.prototype.flatMap is polyfilled', () => {
+  const originalFn = Array.prototype.flatMap
+  Array.prototype.flatMap = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Array.flatMap'])
+
+  Array.prototype.flatMap = originalFn
+})
+
+test('should indicate Object.assign is polyfilled', () => {
+  const originalFn = Object.assign
+  Object.assign = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Object.assign'])
+
+  Object.assign = originalFn
+})
+
+test('should indicate Object.entries is polyfilled', () => {
+  const originalFn = Object.entries
+  Object.entries = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Object.entries'])
+
+  Object.entries = originalFn
+})
+
+test('should indicate Object.values is polyfilled', () => {
+  const originalFn = Object.values
+  Object.values = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Object.values'])
+
+  Object.values = originalFn
+})
+
+test('should indicate Map constructor is polyfilled', () => {
+  const originalFn = Map
+  Map = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Map'])
+
+  Map = originalFn
+})
+
+test('should indicate Set constructor is polyfilled', () => {
+  const originalFn = Set
+  Set = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['Set'])
+
+  Set = originalFn
+})
+
+test('should indicate WeakMap constructor is polyfilled', () => {
+  const originalFn = WeakMap
+  WeakMap = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['WeakMap'])
+
+  WeakMap = originalFn
+})
+
+test('should indicate WeakSet constructor is polyfilled', () => {
+  const originalFn = WeakSet
+  WeakSet = jest.fn(function (...args) {
+    return originalFn.apply(this, args)
+  })
+
+  expect(getPolyfills()).toEqual(['WeakSet'])
+
+  WeakSet = originalFn
+})

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

@@ -12,9 +12,9 @@ import { getConfigurationValue, getInfo, getRuntime } from '../../../common/conf
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { isBrowserScope } from '../../../common/util/global-scope'
-import { FeatureBase } from '../../utils/feature-base'
+import { AggregateBase } from '../../utils/aggregate-base'
 
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)

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

@@ -14,11 +14,11 @@ 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'
+import { AggregateBase } from '../../utils/aggregate-base'
 
 const jsonp = 'NREUM.setToken'
 
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   static featureName = CONSTANTS.FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, CONSTANTS.FEATURE_NAME)
@@ -135,10 +135,10 @@ export class Aggregate extends FeatureBase {
     // 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,
+    const isValidJsonp = submitData.jsonp({
+      url: this.getScheme() + '://' + info.beacon + '/' + protocol + '/' + info.licenseKey + '?' + queryString,
       jsonp
-    )
+    })
     // Usually `drain` is invoked automatically after processing feature flags contained in the JSONP callback from
     // ingest (see `activateFeatures`), so when JSONP cannot execute (as with module workers), we drain manually.
     if (!isValidJsonp) drain(this.agentIdentifier, CONSTANTS.FEATURE_NAME)

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

@@ -17,9 +17,9 @@ import { getInfo, getConfigurationValue, getRuntime } from '../../../common/conf
 import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { FeatureBase } from '../../utils/feature-base'
+import { AggregateBase } from '../../utils/aggregate-base'
 
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)