@newrelic/browser-agent 1.232.1 → 1.233.0

package/src/common/session/session-entity.js

@@ -8,21 +8,29 @@ import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, PREFIX } from './constants'
 import { LocalMemory } from '../storage/local-memory'
 import { InteractionTimer } from '../timer/interaction-timer'
 import { wrapEvents } from '../wrap'
-import { Configurable } from '../config/state/configurable'
+import { getModeledObject } from '../config/state/configurable'
 import { handle } from '../event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
+// this is what can be stored in local storage (not enforced but probably should be)
+// these values should sync between local storage and the parent class props
 const model = {
   value: '',
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplayActive: false,
+  sessionReplay: 0,
   sessionTraceActive: false,
   custom: {}
 }
 
+export const SESSION_EVENTS = {
+  PAUSE: 'session-pause',
+  RESET: 'session-reset',
+  RESUME: 'session-resume'
+}
+
 export class SessionEntity {
   /**
    * Create a self-managing Session Entity. This entity is scoped to the agent identifier which triggered it, allowing for multiple simultaneous session objects to exist.
@@ -39,14 +47,15 @@ export class SessionEntity {
     if (!isBrowserScope) this.storage = new LocalMemory()
     else this.storage = storageAPI
 
+    this.state = {}
+
     this.sync(model)
 
     this.agentIdentifier = agentIdentifier
-
     // key is intended to act as the k=v pair
     this.key = key
     // value is intended to act as the primary value of the k=v pair
-    this.value = value
+    this.state.value = value
 
     this.expiresMs = expiresMs
     this.inactiveMs = inactiveMs
@@ -66,7 +75,7 @@ export class SessionEntity {
     // the set-up of the timer used to expire the session "naturally" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     if (expiresMs) {
-      this.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs)
+      this.state.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs)
       this.expiresTimer = new Timer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -74,16 +83,16 @@ export class SessionEntity {
           this.collectSM('duration', this)
           this.reset()
         }
-      }, this.expiresAt - Date.now())
+      }, this.state.expiresAt - Date.now())
     } else {
-      this.expiresAt = Infinity
+      this.state.expiresAt = Infinity
     }
 
     // the set-up of the timer used to expire the session due to "inactivity" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     // this gets "refreshed" when "activity" is observed
     if (inactiveMs) {
-      this.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs)
+      this.state.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs)
       this.inactiveTimer = new InteractionTimer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -93,21 +102,25 @@ export class SessionEntity {
         },
         // When the inactive timer refreshes, it will update the storage values with an update timestamp
         onRefresh: this.refresh.bind(this),
+        onResume: () => { this.ee.emit(SESSION_EVENTS.RESUME) },
         // When the inactive timer pauses, update the storage values with an update timestamp
-        onPause: () => this.write(new Configurable(this.read(), model)),
+        onPause: () => {
+          if (this.initialized) this.ee.emit(SESSION_EVENTS.PAUSE)
+          this.write(getModeledObject(this.state, model))
+        },
         ee: this.ee,
         refreshEvents: ['click', 'keydown', 'scroll']
-      }, this.inactiveAt - Date.now())
+      }, this.state.inactiveAt - Date.now())
     } else {
-      this.inactiveAt = Infinity
+      this.state.inactiveAt = Infinity
     }
 
     // The fact that the session is "new" or pre-existing is used in some places in the agent.  Session Replay and Trace
     // can use this info to inform whether to trust a new sampling decision vs continue a previous tracking effort.
-    this.isNew = !Object.keys(initialRead).length
+    if (this.isNew === undefined) this.isNew = !Object.keys(initialRead).length
     // if its a "new" session, we write to storage API with the default values.  These values may change over the lifespan of the agent run.
-    // we can use configurable here to help us know and manage what values are being used. -- see "model" above
-    if (this.isNew) this.write(new Configurable(this, model), true)
+    // we can use a modeled object here to help us know and manage what values are being used. -- see "model" above
+    if (this.isNew) this.write(getModeledObject(this.state, model), true)
     else this.sync(initialRead)
 
     this.initialized = true
@@ -119,7 +132,7 @@ export class SessionEntity {
   }
 
   sync (data) {
-    Object.assign(this, data)
+    Object.assign(this.state, data)
   }
 
   /**
@@ -167,7 +180,8 @@ export class SessionEntity {
       if (!data || typeof data !== 'object') return
       // everytime we update, we can update a timestamp for sanity
       data.updatedAt = Date.now()
-      this.sync(data)
+      this.sync(data) // update the parent class "state" properties with the local storage values
+      //
       // TODO - compression would need happen here if we decide to do it
       this.storage.set(this.lookupKey, stringify(data))
       return data
@@ -184,13 +198,11 @@ export class SessionEntity {
     // * stop recording (stn and sr)...
     // * delete the session and start over
     try {
-      if (this.initialized) this.ee.emit('session-reset')
-
+      if (this.initialized) this.ee.emit(SESSION_EVENTS.RESET)
       this.storage.remove(this.lookupKey)
       this.inactiveTimer?.abort?.()
       this.expiresTimer?.clear?.()
-      delete this.custom
-      delete this.value
+      delete this.isNew
 
       this.setup({
         agentIdentifier: this.agentIdentifier,
@@ -211,8 +223,7 @@ export class SessionEntity {
   refresh () {
     // read here & invalidate
     const existingData = this.read()
-    this.inactiveAt = this.getFutureTimestamp(this.inactiveMs)
-    this.write({ ...existingData, inactiveAt: this.inactiveAt })
+    this.write({ ...existingData, inactiveAt: this.getFutureTimestamp(this.inactiveMs) })
   }
 
   /**
@@ -228,7 +239,7 @@ export class SessionEntity {
    * @returns {boolean}
    */
   isInvalid (data) {
-    const requiredKeys = ['value', 'expiresAt', 'inactiveAt']
+    const requiredKeys = Object.keys(model)
     return !requiredKeys.every(x => Object.keys(data).includes(x))
   }
 

package/src/common/session/session-entity.test.js

@@ -41,27 +41,30 @@ describe('constructor', () => {
     expect(session).toMatchObject({
       agentIdentifier: expect.any(String),
       key: expect.any(String),
-      value: expect.any(String),
       expiresMs: expect.any(Number),
-      expiresAt: expect.any(Number),
       expiresTimer: expect.any(Object),
       inactiveMs: expect.any(Number),
-      inactiveAt: expect.any(Number),
       inactiveTimer: expect.any(Object),
       isNew: expect.any(Boolean),
-      sessionReplayActive: expect.any(Boolean),
-      sessionTraceActive: expect.any(Boolean),
-      storage: expect.any(Object)
+      storage: expect.any(Object),
+      state: expect.objectContaining({
+        value: expect.any(String),
+        expiresAt: expect.any(Number),
+        inactiveAt: expect.any(Number),
+        sessionReplay: expect.any(Number),
+        sessionTraceActive: expect.any(Boolean)
+      })
     })
   })
 
   test('can use sane defaults', () => {
     const session = new SessionEntity({ agentIdentifier, key })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -76,47 +79,47 @@ describe('constructor', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100 })
-    expect(session.expiresAt).toEqual(now + 100)
+    expect(session.state.expiresAt).toEqual(now + 100)
   })
 
   test('expiresAt is the correct future timestamp - existing session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity } })
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100, storageAPI: existingData })
-    expect(session.expiresAt).toEqual(now + 5000)
+    expect(session.state.expiresAt).toEqual(now + 5000)
   })
 
   test('expiresAt never expires if 0', () => {
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 0 })
-    expect(session.expiresAt).toEqual(Infinity)
+    expect(session.state.expiresAt).toEqual(Infinity)
   })
 
   test('inactiveAt is the correct future timestamp - new session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
-    expect(session.inactiveAt).toEqual(now + 100)
+    expect(session.state.inactiveAt).toEqual(now + 100)
   })
 
   test('inactiveAt is the correct future timestamp - existing session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity } })
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100, storageAPI: existingData })
-    expect(session.inactiveAt).toEqual(now + 5000)
+    expect(session.state.inactiveAt).toEqual(now + 5000)
   })
 
   test('inactiveAt never expires if 0', () => {
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 0 })
-    expect(session.inactiveAt).toEqual(Infinity)
+    expect(session.state.inactiveAt).toEqual(Infinity)
   })
 
   test('should handle isNew', () => {
     const newSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
     expect(newSession.isNew).toBeTruthy()
 
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity } })
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const existingSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10, storageAPI })
     expect(existingSession.isNew).toBeFalsy()
   })
@@ -125,11 +128,12 @@ describe('constructor', () => {
     // missing required fields
     const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { invalid_fields: true } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -139,11 +143,12 @@ describe('constructor', () => {
     jest.setSystemTime(now)
     const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now - 100, inactiveAt: Infinity } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -153,11 +158,12 @@ describe('constructor', () => {
     jest.setSystemTime(now)
     const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now - 100, expiresAt: Infinity } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -169,10 +175,10 @@ describe('reset()', () => {
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
     const sessionVal = session.value
-    expect(session.value).toBeTruthy()
+    expect(session.state.value).toBeTruthy()
     session.reset()
-    expect(session.value).toBeTruthy()
-    expect(session.value).not.toEqual(sessionVal)
+    expect(session.state.value).toBeTruthy()
+    expect(session.state.value).not.toEqual(sessionVal)
   })
 
   test('custom data should be wiped on reset', () => {
@@ -180,12 +186,12 @@ describe('reset()', () => {
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
     session.syncCustomAttribute('test', 123)
-    expect(session.custom.test).toEqual(123)
+    expect(session.state.custom.test).toEqual(123)
     expect(session.read().custom.test).toEqual(123)
 
     // simulate a timer expiring
     session.reset()
-    expect(session.custom?.test).toEqual(undefined)
+    expect(session.state.custom?.test).toEqual(undefined)
     expect(session.read()?.custom?.test).toEqual(undefined)
   })
 })
@@ -199,13 +205,13 @@ describe('read()', () => {
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
 
   test('"pre-existing" sessions get data from read()', () => {
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity } })
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
     expect(session.isNew).toBeFalsy()
     expect(session.read()).toEqual(expect.objectContaining({
@@ -219,20 +225,20 @@ describe('read()', () => {
 describe('write()', () => {
   test('write() sets data to top-level wrapper', () => {
     const session = new SessionEntity({ agentIdentifier, key })
-    expect(session.value).not.toEqual(value)
-    expect(session.expiresAt).not.toEqual(Infinity)
-    expect(session.inactiveAt).not.toEqual(Infinity)
-    session.write({ value, expiresAt: Infinity, inactiveAt: Infinity })
-    expect(session.value).toEqual(value)
-    expect(session.expiresAt).toEqual(Infinity)
-    expect(session.inactiveAt).toEqual(Infinity)
+    expect(session.state.value).not.toEqual(value)
+    expect(session.state.expiresAt).not.toEqual(Infinity)
+    expect(session.state.inactiveAt).not.toEqual(Infinity)
+    session.write({ ...session.state, value, expiresAt: Infinity, inactiveAt: Infinity })
+    expect(session.state.value).toEqual(value)
+    expect(session.state.expiresAt).toEqual(Infinity)
+    expect(session.state.inactiveAt).toEqual(Infinity)
   })
 
   test('write() sets data that read() can access', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key })
-    session.write({ value, expiresAt: now + 100, inactiveAt: now + 100 })
+    session.write({ ...session.state, value, expiresAt: now + 100, inactiveAt: now + 100 })
     const read = session.read()
     expect(read.value).toEqual(value)
     expect(read.expiresAt).toEqual(now + 100)
@@ -259,30 +265,30 @@ describe('refresh()', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
-    expect(session.inactiveAt).toEqual(now + 100)
+    expect(session.state.inactiveAt).toEqual(now + 100)
     jest.setSystemTime(now + 1000)
     session.refresh()
-    expect(session.inactiveAt).toEqual(now + 100 + 1000)
+    expect(session.state.inactiveAt).toEqual(now + 100 + 1000)
   })
 
   test('refresh resets the entity if expiresTimer is invalid', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, value })
-    expect(session.value).toEqual(value)
-    session.write({ ...session.read(), expiresAt: now - 1 })
+    expect(session.state.value).toEqual(value)
+    session.write({ ...session.state, expiresAt: now - 1 })
     session.refresh()
-    expect(session.value).not.toEqual(value)
+    expect(session.state.value).not.toEqual(value)
   })
 
   test('refresh resets the entity if inactiveTimer is invalid', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, value })
-    expect(session.value).toEqual(value)
-    session.write({ ...session.read(), inactiveAt: now - 1 })
+    expect(session.state.value).toEqual(value)
+    session.write({ ...session.state, inactiveAt: now - 1 })
     session.refresh()
-    expect(session.value).not.toEqual(value)
+    expect(session.state.value).not.toEqual(value)
   })
 })
 
@@ -292,20 +298,20 @@ describe('syncCustomAttribute()', () => {
 
     // if custom has never been set, and a "delete" action is triggered, do nothing
     session.syncCustomAttribute('test', null)
-    expect(session?.custom?.test).toEqual(undefined)
+    expect(session?.state?.custom?.test).toEqual(undefined)
 
     session.syncCustomAttribute('test', 1)
-    expect(session?.custom?.test).toEqual(1)
+    expect(session?.state?.custom?.test).toEqual(1)
 
     session.syncCustomAttribute('test', 'string')
-    expect(session?.custom?.test).toEqual('string')
+    expect(session?.state?.custom?.test).toEqual('string')
 
     session.syncCustomAttribute('test', false)
-    expect(session?.custom?.test).toEqual(false)
+    expect(session?.state?.custom?.test).toEqual(false)
 
     // null specifically deletes the object completely
     session.syncCustomAttribute('test', null)
-    expect(session?.custom?.test).toEqual(undefined)
+    expect(session?.state?.custom?.test).toEqual(undefined)
   })
 
   test('Only runs in browser scope', () => {

package/src/common/timer/interaction-timer.js

@@ -6,8 +6,9 @@ import { isBrowserScope } from '../util/global-scope'
 export class InteractionTimer extends Timer {
   constructor (opts, ms) {
     super(opts, ms)
-    this.onRefresh = opts.onRefresh
-    this.onPause = opts.onPause
+    this.onPause = typeof opts.onPause === 'function' ? opts.onPause : () => { /* noop */ }
+    this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => { /* noop */ }
+    this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => { /* noop */ }
 
     // used by pause/resume
     this.remainingMs = undefined
@@ -42,7 +43,10 @@ export class InteractionTimer extends Timer {
       subscribeToVisibilityChange((state) => {
         if (state === 'hidden') this.pause()
         // vis change --> visible is treated like a new interaction with the page
-        else this.refresh()
+        else {
+          this.onResume()
+          this.refresh()
+        }
       }, false, false, this.abortController?.signal)
     }
   }
@@ -53,7 +57,7 @@ export class InteractionTimer extends Timer {
   }
 
   pause () {
-    this.onPause?.()
+    this.onPause()
     clearTimeout(this.timer)
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp)
   }
@@ -63,13 +67,6 @@ export class InteractionTimer extends Timer {
     this.timer = this.create(cb, ms)
     this.startTimestamp = Date.now()
     this.remainingMs = undefined
-    this.onRefresh?.()
+    this.onRefresh()
   }
-
-  // NOT CURRENTLY UTILIZED BY ANYTHING
-  // resume () {
-  //   if (!this.remainingMs || !this.isValid()) return
-  //   this.timer = this.create(this.cb, this.remainingMs)
-  //   this.remainingMs = undefined
-  // }
 }

package/src/common/url/protocol.test.js

@@ -1,4 +1,3 @@
-import { faker } from '@faker-js/faker'
 import { isFileProtocol } from './protocol'
 
 test('should return true when location url contains file protocol', () => {

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

@@ -12,7 +12,8 @@ const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa]
+  spa: [FEATURE_NAMES.spa],
+  sr: [FEATURE_NAMES.sessionReplay]
 }
 
 export function activateFeatures (flags, agentIdentifier) {
@@ -28,7 +29,6 @@ export function activateFeatures (flags, agentIdentifier) {
     if (activatedFeatures[flag]) {
       return
     }
-
     handle('feat-' + flag, [], undefined, bucketMap[flag], sharedEE)
     activatedFeatures[flag] = true
   })

package/src/common/util/submit-data.js

@@ -7,11 +7,13 @@ export const submitData = {}
 
 /**
  * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} jsonp
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string} args.jsonp - The string name of the jsonp cb method
+ * @returns {XMLHttpRequest}
  * @returns {Element}
  */
-submitData.jsonp = function jsonp (url, jsonp) {
+submitData.jsonp = function jsonp ({ url, jsonp }) {
   try {
     if (isWorkerScope) {
       try {
@@ -19,7 +21,7 @@ submitData.jsonp = function jsonp (url, jsonp) {
       } catch (e) {
         // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
         // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
-        submitData.xhrGet(url + '&jsonp=' + jsonp)
+        submitData.xhrGet({ url: url + '&jsonp=' + jsonp })
         return false
       }
     } else {
@@ -35,18 +37,21 @@ submitData.jsonp = function jsonp (url, jsonp) {
   }
 }
 
-submitData.xhrGet = function xhrGet (url) {
-  return submitData.xhr(url, undefined, false, 'GET')
+submitData.xhrGet = function xhrGet ({ url }) {
+  return submitData.xhr({ url, sync: false, method: 'GET' })
 }
 
 /**
  * Send via XHR
- * @param {string} url
- * @param {string} body
- * @param {boolean} sync
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
+ * @param {boolean=} args.sync - Run XHR as Synchronous
+ * @param {string=} [args.method=POST] - The XHR method to use
+ * @param {{key: string, value: string}[]} [args.headers] - The headers to attach
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr (url, body, sync, method = 'POST') {
+submitData.xhr = function xhr ({ url, body, sync, method = 'POST', headers = [{ key: 'content-type', value: 'text/plain' }] }) {
   var request = new XMLHttpRequest()
 
   request.open(method, url, !sync)
@@ -57,7 +62,10 @@ submitData.xhr = function xhr (url, body, sync, method = 'POST') {
     // do nothing
   }
 
-  request.setRequestHeader('content-type', 'text/plain')
+  headers.forEach(header => {
+    request.setRequestHeader(header.key, header.value)
+  })
+
   request.send(body)
   return request
 }
@@ -71,10 +79,12 @@ submitData.xhr = function xhr (url, body, sync, method = 'POST') {
 
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @returns {Element}
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @returns {HTMLImageElement}
  */
-submitData.img = function img (url) {
+submitData.img = function img ({ url }) {
+  console.log('img url', url)
   var element = new Image()
   element.src = url
   return element
@@ -82,11 +92,12 @@ submitData.img = function img (url) {
 
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} body
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-submitData.beacon = function (url, body) {
+submitData.beacon = function ({ url, body }) {
   // Navigator has to be bound to ensure it does not error in some browsers
   // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
   const send = window.navigator.sendBeacon.bind(window.navigator)

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

@@ -70,7 +70,7 @@ export function wrapFetch (sharedEE) {
     var fn = target[name]
     if (typeof fn === 'function') {
       target[name] = function () {
-        var args = Array.from(arguments)
+        var args = [...arguments]
 
         var ctx = {}
         // we are wrapping args in an array so we can preserve the reference

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

@@ -76,7 +76,7 @@ export function createWrapperWithEmitter (emitter, always) {
 
       try {
         originalThis = this
-        args = Array.from(arguments)
+        args = [...arguments]
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis)

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

@@ -71,7 +71,7 @@ export function wrapPromise (sharedEE) {
       WrappedPromise[method] = function (subPromises) { // use our own wrapped version of "Promise.all" and ".race" static fns
         let finalized = false
 
-        Array.from(subPromises || []).forEach(sub => {
+        ;[...subPromises || []].forEach(sub => {
           this.resolve(sub).then(setNrId(method === 'all'), setNrId(false))
         })
 

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

@@ -13,9 +13,9 @@ import { FEATURE_NAME } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
-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)