@newrelic/browser-agent 1.237.1 → 1.239.0

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

@@ -42,10 +42,8 @@ export class SessionEntity {
    * expiresMs and inactiveMs are used to "expire" the session, but can be overridden in the constructor. Pass 0 to disable expiration timers.
    */
   constructor (opts) {
-    this.setup(opts)
-  }
+    const { agentIdentifier, key, storage } = opts
 
-  setup ({ agentIdentifier, key, storage, value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS }) {
     if (!agentIdentifier || !key || !storage) {
       throw new Error(`Missing required field(s):${!agentIdentifier ? ' agentID' : ''}${!key ? ' key' : ''}${!storage ? ' storage' : ''}`)
     }
@@ -53,20 +51,24 @@ export class SessionEntity {
     this.storage = storage
     this.state = {}
 
-    this.sync(model)
-
     // key is intended to act as the k=v pair
     this.key = key
+
+    this.ee = ee.get(agentIdentifier)
+    wrapEvents(this.ee)
+    this.setup(opts)
+  }
+
+  setup ({ value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS }) {
+    this.state = {}
+    this.sync(model)
+
     // value is intended to act as the primary value of the k=v pair
     this.state.value = value
 
     this.expiresMs = expiresMs
     this.inactiveMs = inactiveMs
 
-    this.ee = ee.get(agentIdentifier)
-
-    wrapEvents(this.ee)
-
     // the first time the session entity class is instantiated, we check the storage API for an existing
     // object. If it exists, the values inside the object are used to inform the timers that run locally.
     // if the initial read is empty, it allows us to set a "fresh" "new" session immediately.

package/src/common/storage/first-party-cookies.js

@@ -8,24 +8,25 @@ export class FirstPartyCookies {
       var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'))
       if (match) return match[2]
     } catch (err) {
+      // Error is ignored
       return ''
     }
   }
 
   set (key, value) {
     try {
-      const cookie = `${key}=${value}; Domain=${domain}; Path=/`
+      const cookie = `${key}=${value}; Domain=${this.domain}; Path=/`
       document.cookie = cookie
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 
   remove (key) {
     try {
-      return document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=${domain}; Path=/`
+      document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=${this.domain}; Path=/`
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 }

package/src/common/storage/local-storage.js

@@ -5,6 +5,7 @@ export class LocalStorage {
       // Cast it back to undefined if it doesnt exist
       return localStorage.getItem(key) || undefined
     } catch (err) {
+      // Error is ignored
       return ''
     }
   }
@@ -14,7 +15,7 @@ export class LocalStorage {
       if (value === undefined || value === null) return this.remove(key)
       return localStorage.setItem(key, value)
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 
@@ -22,7 +23,7 @@ export class LocalStorage {
     try {
       localStorage.removeItem(key)
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 }

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

@@ -41,29 +41,25 @@ describe('constructor', () => {
   })
 
   test('refresh type timers set event listeners', () => {
-    // eslint-disable-next-line
     let ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'click' }]) }) }
     let it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
     // scroll, keypress, click
     expect(ee.on).toHaveBeenCalledTimes(1)
     expect(it.onRefresh).toHaveBeenCalledTimes(1)
 
-    // eslint-disable-next-line
-     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'scroll' }]) }) }
+    ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'scroll' }]) }) }
     it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
     // scroll, keypress, click
     expect(ee.on).toHaveBeenCalledTimes(1)
     expect(it.onRefresh).toHaveBeenCalledTimes(1)
 
-    // eslint-disable-next-line
-     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
+    ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
     it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
     // scroll, keypress, click
     expect(ee.on).toHaveBeenCalledTimes(1)
     expect(it.onRefresh).toHaveBeenCalledTimes(1)
 
     const aelSpy = jest.spyOn(document, 'addEventListener')
-    // eslint-disable-next-line
     ee = { on: jest.fn().mockImplementation((evt, cb) => { cb([{ type: 'keydown' }]) }) }
     it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
     // visibility change
@@ -81,7 +77,6 @@ describe('create()', () => {
   })
 
   test('Create can fallback to use defaults', () => {
-    let called = 0
     const timer1 = new InteractionTimer({ onEnd: jest.fn() }, 100)
     timer1.create()
 
@@ -136,6 +131,26 @@ describe('pause()', () => {
   })
 })
 
+describe('resume()', () => {
+  test('resume allows the callback continue firing', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.pause()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.resume()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('resume fires the refresh callback', () => {
+    const timer = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn() }, 100)
+    timer.pause()
+    timer.resume()
+    expect(timer.onRefresh).toHaveBeenCalledTimes(1)
+  })
+})
+
 describe('clear()', () => {
   test('clear prevents the callback from firing and deletes the pointer', () => {
     const timer = new InteractionTimer({ onEnd: jest.fn() }, 100)
@@ -165,3 +180,33 @@ describe('isValid', () => {
     expect(timer.isValid()).toEqual(false)
   })
 })
+
+describe('abort()', () => {
+  test('should unregister the event emitter listener', () => {
+    const ee = { on: jest.fn(), removeEventListener: jest.fn() }
+    const it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn(), ee }, 100)
+
+    it.abort()
+
+    expect(ee.on).toHaveBeenCalledTimes(1)
+    expect(ee.on).toHaveBeenCalledWith('fn-end', expect.any(Function))
+
+    expect(ee.removeEventListener).toHaveBeenCalledTimes(1)
+    expect(ee.removeEventListener).toHaveBeenCalledWith('fn-end', expect.any(Function))
+
+    // Verify the same function is passed to both methods
+    expect(jest.mocked(ee.on).mock.calls[0][1]).toEqual(jest.mocked(ee.removeEventListener).mock.calls[0][1])
+  })
+
+  test('should not attempt to unregister the event emitter listener when an event emitter was not supplied', () => {
+    const it = new InteractionTimer({ onEnd: jest.fn(), onRefresh: jest.fn() }, 100)
+
+    expect(it.ee).toBeUndefined()
+    expect(it.refreshHandler).toBeUndefined()
+
+    it.abort()
+
+    expect(it.ee).toBeUndefined()
+    expect(it.refreshHandler).toBeUndefined()
+  })
+})

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

@@ -24,12 +24,14 @@ export class InteractionTimer extends Timer {
 
     if (isBrowserScope && opts.ee) {
       if (opts.ee) {
+        this.ee = opts.ee
         const debouncedRefresh = debounce(this.refresh.bind(this), 500, { leading: true })
-        opts.ee.on('fn-end', (evts) => {
+        this.refreshHandler = (evts) => {
           if (opts.refreshEvents.includes(evts?.[0]?.type)) {
             debouncedRefresh()
           }
-        })
+        }
+        opts.ee.on('fn-end', this.refreshHandler)
       }
 
       // watch for the vis state changing.  If the page is hidden, the local inactivity timer should be paused
@@ -43,10 +45,7 @@ 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()
-          this.onResume() // emit resume event after state updated
-        }
+        else this.resume()
       }, false, false, this.abortController?.signal)
     }
   }
@@ -54,6 +53,11 @@ export class InteractionTimer extends Timer {
   abort () {
     this.clear()
     this.abortController?.abort()
+
+    if (this.refreshHandler) {
+      this.ee.removeEventListener('fn-end', this.refreshHandler)
+      this.refreshHandler = this.ee = null
+    }
   }
 
   pause () {
@@ -62,6 +66,11 @@ export class InteractionTimer extends Timer {
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp)
   }
 
+  resume () {
+    this.refresh()
+    this.onResume() // emit resume event after state updated
+  }
+
   refresh (cb, ms) {
     this.clear()
     this.timer = this.create(cb, ms)

package/src/common/timer/timer.test.js

@@ -51,7 +51,6 @@ describe('create()', () => {
   })
 
   test('Create can fallback to use defaults', () => {
-    let called = 0
     const timer1 = new Timer({ onEnd: jest.fn() }, 100)
     timer1.create()
 

package/src/common/timing/nav-timing.js

@@ -28,7 +28,7 @@ var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent'
 export var navTimingValues = []
 
 function getPntType (type) {
-  if (typeof type == 'number') return type
+  if (typeof type === 'number') return type
   const types = {
     navigate: undefined,
     reload: 1,

package/src/common/unload/eol.js

@@ -3,8 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { windowAddEventListener } from '../event-listener/event-listener-opts'
-import { single } from '../util/invoke'
-import { ffVersion, globalScope, isWorkerScope, isBrowserScope } from '../constants/runtime'
+import { globalScope, isWorkerScope, isBrowserScope } from '../constants/runtime'
 import { subscribeToVisibilityChange } from '../window/page-visibility'
 
 if (isWorkerScope) {
@@ -23,37 +22,12 @@ if (isWorkerScope) {
  * Subscribes a provided callback to the time/event when the agent should treat it as end-of-life.
  * This is used, for example, to submit a final harvest and send all remaining data on best-effort.
  * @param {function} cb - func to run before or during the last reliable event or time of an env's life span
- * @param {boolean} allowBFCache - (temp) feature flag to gate new v1222 BFC support
  */
-export function subscribeToEOL (cb, allowBFCache) {
+export function subscribeToEOL (cb) {
   if (isBrowserScope) {
-    if (allowBFCache) {
-      subscribeToVisibilityChange(cb, true) // when user switches tab or hides window, esp. mobile scenario
-      windowAddEventListener('pagehide', cb) // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
-      // --this ought to be removed once support for version below 14.5 phases out
-    } else {
-      var oneCall = single(cb)
-
-      // Firefox has a bug wherein a slow-loading resource loaded from the 'pagehide'
-      // or 'unload' event will delay the 'load' event firing on the next page load.
-      // In Firefox versions that support sendBeacon, this doesn't matter, because
-      // we'll use it instead of an image load for our final harvest.
-      //
-      // Some Safari versions never fire the 'unload' event for pages that are being
-      // put into the WebKit page cache, so we *need* to use the pagehide event for
-      // the final submission from Safari.
-      //
-      // Generally speaking, we will try to submit our final harvest from either
-      // pagehide or unload, whichever comes first, but in Firefox, we need to avoid
-      // attempting to submit from pagehide to ensure that we don't slow down loading
-      // of the next page.
-      if (!ffVersion || navigator.sendBeacon) {
-        windowAddEventListener('pagehide', oneCall)
-      } else {
-        windowAddEventListener('beforeunload', oneCall)
-      }
-      windowAddEventListener('unload', oneCall)
-    }
+    subscribeToVisibilityChange(cb, true) // when user switches tab or hides window, esp. mobile scenario
+    windowAddEventListener('pagehide', cb) // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
+    // --this ought to be removed once support for version below 14.5 phases out
   } else if (isWorkerScope) {
     globalScope.cleanupTasks.push(cb) // close() should run these tasks before quitting thread
   }

package/src/common/url/__mocks__/parse-url.js

@@ -0,0 +1,15 @@
+export function parseUrl (url) {
+  try {
+    const result = new URL(url)
+
+    return {
+      hostname: result.hostname,
+      port: result.port || result.protocol.startsWith('https') ? '443' : '80',
+      pathname: result.pathname,
+      protocol: result.protocol.replace(':', ''),
+      sameOrigin: false
+    }
+  } catch (err) {
+    return {}
+  }
+}

package/src/common/url/{encode.component-test.js → encode.test.js}

@@ -46,6 +46,7 @@ describe('object encoding', () => {
   })
 
   test('handles circular objects', () => {
+    // eslint-disable-next-line sonarjs/prefer-object-literal
     const circular = {}
     circular.circular = circular
     const input = { bar: ['a', circular, 'c'] }

package/src/common/util/__mocks__/get-or-set.js

@@ -0,0 +1,5 @@
+export const getOrSet = jest.fn((obj, prop, getVal) => {
+  if (obj[prop]) return obj[prop]
+  obj[prop] = getVal()
+  return obj[prop]
+})

package/src/common/util/__mocks__/invoke.js

@@ -0,0 +1 @@
+export const single = jest.fn(cb => cb)

package/src/common/util/data-size.test.js

@@ -47,7 +47,6 @@ describe('dataSize', () => {
     const input = {
       [faker.datatype.uuid()]: faker.lorem.sentence()
     }
-    const expectedSize = faker.datatype.number({ min: 1000, max: 10000 })
 
     jest.spyOn(stringifyModule, 'stringify').mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
 

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

@@ -4,7 +4,6 @@
  */
 import { ee } from '../event-emitter/contextual-ee'
 import { handle } from '../event-emitter/handle'
-import { drain } from '../drain/drain'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 const bucketMap = {
@@ -15,26 +14,25 @@ const bucketMap = {
   sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
 }
 
+const sentIds = new Set()
+
 /** Note that this function only processes each unique flag ONCE, with the first occurrence of each flag and numeric value determining its switch on/off setting. */
 export function activateFeatures (flags, agentIdentifier) {
   const sharedEE = ee.get(agentIdentifier)
   if (!(flags && typeof flags === 'object')) return
 
-  Object.entries(flags).forEach(([flag, num]) => {
-    if (activatedFeatures[flag] !== undefined) return
-
-    if (bucketMap[flag]) {
-      bucketMap[flag].forEach(feat => {
-        if (!num) handle('block-' + flag, [], undefined, feat, sharedEE)
-        else handle('feat-' + flag, [], undefined, feat, sharedEE)
-
-        handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE) // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
-      })
-    } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE) // not sure what other flags are overlooked, but there's a test for ones not in the map --
-    // ^^^ THIS DOESN'T ACTUALLY DO ANYTHHING AS UNDEFINED/FEATURE GROUP ISN'T DRAINED
-
-    activatedFeatures[flag] = Boolean(num)
-  })
+  if (!sentIds.has(agentIdentifier)) {
+    Object.entries(flags).forEach(([flag, num]) => {
+      if (bucketMap[flag]) {
+        bucketMap[flag].forEach(feat => {
+          if (!num) handle('block-' + flag, [], undefined, feat, sharedEE)
+          else handle('feat-' + flag, [], undefined, feat, sharedEE)
+          handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE) // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
+        })
+      } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE) // not sure what other flags are overlooked, but there's a test for ones not in the map --
+      activatedFeatures[flag] = Boolean(num)
+    })
+  }
 
   // Let the features waiting on their respective flags know that RUM response was received and that any missing flags are interpreted as bad entitlement / "off".
   // Hence, those features will not be hanging forever if their flags aren't included in the response.
@@ -44,7 +42,7 @@ export function activateFeatures (flags, agentIdentifier) {
       activatedFeatures[flag] = false
     }
   })
-  drain(agentIdentifier, FEATURE_NAMES.pageViewEvent)
+  sentIds.add(agentIdentifier)
 }
 
 export const activatedFeatures = {}

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

@@ -48,7 +48,7 @@ const bucketMap = {
 
 test('emits the right events when feature flag = 1', () => {
   const flags = {}
-  Object.keys(bucketMap).forEach(flag => flags[flag] = 1)
+  Object.keys(bucketMap).forEach(flag => { flags[flag] = 1 })
   activateFeatures(flags, agentIdentifier)
 
   const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
@@ -57,15 +57,14 @@ test('emits the right events when feature flag = 1', () => {
   expect(handleModule.handle).toHaveBeenCalledTimes(14)
   expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
   expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [true], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event')
 
-  Object.keys(flags).forEach(flag => flags[flag] = true)
+  Object.keys(flags).forEach(flag => { flags[flag] = true })
   expect(activatedFeatures).toEqual(flags)
 })
 
 test('emits the right events when feature flag = 0', () => {
   const flags = {}
-  Object.keys(bucketMap).forEach(flag => flags[flag] = 0)
+  Object.keys(bucketMap).forEach(flag => { flags[flag] = 0 })
   activateFeatures(flags, agentIdentifier)
 
   const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
@@ -74,9 +73,8 @@ test('emits the right events when feature flag = 0', () => {
   expect(handleModule.handle).toHaveBeenCalledTimes(14)
   expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'block-stn', [], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
   expect(handleModule.handle).toHaveBeenLastCalledWith('rumresp-sr', [false], undefined, FEATURE_NAMES.sessionTrace, sharedEE)
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event')
 
-  Object.keys(flags).forEach(flag => flags[flag] = false)
+  Object.keys(flags).forEach(flag => { flags[flag] = false })
   expect(activatedFeatures).toEqual(flags)
 })
 
@@ -92,7 +90,5 @@ test('only the first activate of the same feature is respected', () => {
   expect(handleModule.handle).toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE1)
   expect(handleModule.handle).toHaveBeenNthCalledWith(2, 'rumresp-stn', [true], undefined, 'session_trace', sharedEE1)
   expect(handleModule.handle).not.toHaveBeenNthCalledWith(1, 'feat-stn', [], undefined, 'session_trace', sharedEE2)
-  expect(drainModule.drain).toHaveBeenCalledWith(agentIdentifier, 'page_view_event')
-  expect(drainModule.drain).toHaveBeenCalledTimes(2)
   expect(activatedFeatures.stn).toBeTruthy()
 })

package/src/common/util/invoke.js

@@ -26,7 +26,7 @@ export function debounce (func, timeout = 500, options = {}) {
   return (...args) => {
     if (leading && timer === undefined) {
       func.apply(this, args)
-      timer = setTimeout(() => timer = clearTimeout(timer), timeout)
+      timer = setTimeout(() => { timer = clearTimeout(timer) }, timeout)
     }
 
     if (!leading) {

package/src/common/util/obfuscate.js

@@ -57,11 +57,9 @@ export function validateRules (rules) {
     }
 
     var replacement = rules[i].replacement
-    if (replacement) {
-      if (typeof replacement !== 'string') {
-        warn('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)')
-        invalidReplacementDetected = true
-      }
+    if (replacement && typeof replacement !== 'string') {
+      warn('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)')
+      invalidReplacementDetected = true
     }
   }
 

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

@@ -66,7 +66,7 @@ describe('xhr', () => {
       this._withCredentials = false
       Object.defineProperty(this, 'withCredentials', {
         get: jest.fn(() => this._withCredentials),
-        set: jest.fn((val) => this._withCredentials = val)
+        set: jest.fn((val) => { this._withCredentials = val })
       })
     })
   })

package/src/common/util/traverse.js

@@ -19,6 +19,7 @@ export function applyFnToProps (obj, fn, type = 'string', ignoreKeys = []) {
     if (typeof obj[property] === 'object') {
       applyFnToProps(obj[property], fn, type, ignoreKeys)
     } else {
+      // eslint-disable-next-line valid-typeof
       if (typeof obj[property] === type && !ignoreKeys.includes(property)) obj[property] = fn(obj[property])
     }
   })

package/src/common/window/__mocks__/nreum.js

@@ -0,0 +1,12 @@
+export const defaults = {}
+export const gosNREUM = jest.fn(() => ({}))
+export const gosNREUMInfo = jest.fn(() => ({}))
+export const gosNREUMLoaderConfig = jest.fn(() => ({}))
+export const gosNREUMInit = jest.fn(() => ({}))
+export const gosNREUMOriginals = jest.fn(() => ({}))
+export const gosNREUMInitializedAgents = jest.fn(() => ({}))
+export const addToNREUM = jest.fn(() => ({}))
+export const NREUMinitialized = jest.fn(() => ({}))
+export const gosCDN = jest.fn(() => (newrelicGlob))
+
+const newrelicGlob = {}

package/src/common/window/page-visibility.js

@@ -12,11 +12,10 @@ import { documentAddEventListener } from '../event-listener/event-listener-opts'
  */
 export function subscribeToVisibilityChange (cb, toHiddenOnly = false, capture, abortSignal) {
   documentAddEventListener('visibilitychange', handleVisibilityChange, capture, abortSignal)
-  return
 
   function handleVisibilityChange () {
     if (toHiddenOnly) { // trigger cb on change to hidden state only
-      if (document.visibilityState == 'hidden') cb()
+      if (document.visibilityState === 'hidden') cb()
       return
     }
     cb(document.visibilityState)

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

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

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

@@ -6,9 +6,8 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee'
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
-import { flag } from './wrap-function'
 
 var prefix = 'fetch-'
 var bodyPrefix = prefix + 'body-'
@@ -16,7 +15,6 @@ var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData']
 var Req = globalScope.Request
 var Res = globalScope.Response
 var proto = 'prototype'
-var ctxId = 'nr@context'
 
 const wrapped = {}
 
@@ -76,7 +74,7 @@ export function wrapFetch (sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx)
         var dtPayload
-        if (ctx[ctxId] && ctx[ctxId].dt) dtPayload = ctx[ctxId].dt
+        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt
 
         var origPromiseFromFetch = fn.apply(this, args)