@newrelic/browser-agent 1.237.1 → 1.238.0

package/src/common/deny-list/deny-list.test.js

@@ -1,31 +1,104 @@
-describe('Setting deny list', () => {
-  let DlMod
-  beforeEach(() => {
-    jest.isolateModules(() => import('./deny-list.js').then(m => DlMod = m)) // give every test its own denyList (sandbox)
-  })
-
-  it('respects path', () => {
-    DlMod.setDenyList(['bam.nr-data.net/somepath'])
-
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '/somepath' })).toBeFalsy() // shouldCollectEvent returns 'false' when there IS a match...
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'https', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '' })).toBeTruthy()
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '/someotherpath' })).toBeTruthy()
-  })
-
-  it('ignores port', () => {
-    DlMod.setDenyList(['bam.nr-data.net:1234'])
-
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '', port: '4321' })).toBeFalsy()
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'http', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '' })).toBeTruthy()
-  })
-
-  it('ignores protocol', () => {
-    DlMod.setDenyList(['http://bam.nr-data.net'])
-
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '', protocol: 'https' })).toBeFalsy()
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'https', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
-    expect(DlMod.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '', protocol: 'http' })).toBeTruthy()
-  })
+jest.enableAutomock()
+jest.unmock('./deny-list')
+
+let denyListModule
+
+beforeEach(async () => {
+  denyListModule = await import('./deny-list')
+})
+
+afterEach(() => {
+  jest.resetModules()
+})
+
+test('domain-only blocks all subdomains and all paths', () => {
+  denyListModule.setDenyList(['foo.com'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a/b' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/c/d' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'oo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeTruthy()
+})
+
+test('subdomain blocks further subdomains, but not parent domain', () => {
+  denyListModule.setDenyList(['bar.foo.com'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.foo.com', pathname: '/a' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.foo.com', pathname: '/a/b' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.bar.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.bar.foo.com', pathname: '/a' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.bar.foo.com', pathname: '/a/b' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a/b' })).toBeTruthy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'oo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeTruthy()
+})
+
+test('* blocks all domains', () => {
+  denyListModule.setDenyList(['*'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.bar.com', pathname: '/' })).toBeFalsy()
+})
+
+test('respects path', () => {
+  denyListModule.setDenyList(['bam.nr-data.net/somepath'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '/somepath' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'https', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '/someotherpath' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '/some/otherpath' })).toBeTruthy()
+})
+
+test('ignores port', () => {
+  denyListModule.setDenyList(['bam.nr-data.net:1234'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '', port: '4321' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'http', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '' })).toBeTruthy()
+})
+
+test('ignores protocol', () => {
+  denyListModule.setDenyList(['http://bam.nr-data.net'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '', protocol: 'https' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'https', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '', protocol: 'http' })).toBeTruthy()
+})
+
+test.each([
+  null,
+  undefined,
+  '!@$%^*',
+  'https://example.com/http://foo.bar/'
+])('ignores invalid deny list value %s', (denyListValue) => {
+  denyListModule.setDenyList([denyListValue])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a/b' })).toBeTruthy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/c/d' })).toBeTruthy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'oo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeTruthy()
 })

package/src/common/event-emitter/{contextual-ee.test.js → contextual-ee.component-test.js}

@@ -24,19 +24,18 @@ afterEach(() => {
 })
 
 describe('global event-emitter', () => {
-  test('it returns the event-emitter defined on window.NREUM', async () => {
-    const mockEE = {}
-    mockNREUM.ee = mockEE
-
+  test('it sets the global event-emitter on window.NREUM when it does not already exist', async () => {
     const { ee } = await import('./contextual-ee')
 
-    expect(ee).toEqual(mockEE)
+    expect(ee).toEqual(mockNREUM.ee)
   })
 
-  test('it sets the global event-emitter on window.NREUM', async () => {
+  test('it does not set the global event-emitter on window.NREUM when it already exists', async () => {
+    mockNREUM.ee = {}
+
     const { ee } = await import('./contextual-ee')
 
-    expect(ee).toEqual(mockNREUM.ee)
+    expect(ee).not.toEqual(mockNREUM.ee)
   })
 })
 
@@ -79,7 +78,9 @@ describe('event-emitter context', () => {
 
     const result = ee.context()
 
-    expect(result).toEqual({})
+    expect(result).toEqual(expect.objectContaining({
+      contextId: expect.stringContaining('nr@context:')
+    }))
   })
 
   test('it returns the same context', async () => {
@@ -87,7 +88,7 @@ describe('event-emitter context', () => {
 
     const result = ee.context()
 
-    expect(result).toEqual(ee.context(result))
+    expect(result).toBe(ee.context(result))
   })
 
   test('it adds the context to the provided object', async () => {
@@ -95,8 +96,9 @@ describe('event-emitter context', () => {
 
     const obj = {}
     const result = ee.context(obj)
+    const ctxKey = Object.getOwnPropertyNames(obj).find(k => k.startsWith('nr@context'))
 
-    expect(result).toEqual(obj['nr@context'])
+    expect(result).toBe(obj[ctxKey])
   })
 })
 
@@ -281,30 +283,11 @@ describe('event-emitter emit', () => {
         scopeEE,
         eventType,
         eventArgs,
-        {}
+        expect.objectContaining({
+          contextId: expect.stringContaining('nr@context:')
+        })
       ])
     ]))
     expect(ee.backlog.feature).toEqual(scopeEE.backlog.feature)
   })
 })
-
-describe('getOrSetContext', () => {
-  test('it returns a new context', async () => {
-    const { getOrSetContext } = await import('./contextual-ee')
-
-    const obj = {}
-    const result = getOrSetContext(obj)
-
-    expect(result).toEqual({})
-    expect(result).toEqual(obj['nr@context'])
-  })
-
-  test('it returns the same context', async () => {
-    const { getOrSetContext } = await import('./contextual-ee')
-
-    const obj = {}
-    const result = getOrSetContext(obj)
-
-    expect(getOrSetContext(obj)).toEqual(result)
-  })
-})

package/src/common/event-emitter/contextual-ee.js

@@ -5,25 +5,22 @@
 
 import { gosNREUM } from '../window/nreum'
 import { getOrSet } from '../util/get-or-set'
-import { mapOwn } from '../util/map-own'
 import { getRuntime } from '../config/config'
+import { EventContext } from './event-context'
+import { bundleId } from '../ids/bundle-id'
 
-var ctxId = 'nr@context'
-
+// create a unique id to store event context data for the current agent bundle
+const contextId = `nr@context:${bundleId}`
 // create global emitter instance that can be shared among bundles
-let nr = gosNREUM()
-var globalInstance
+const globalInstance = ee(undefined, 'globalEE')
 
-if (nr.ee) {
-  globalInstance = nr.ee
-} else {
-  globalInstance = ee(undefined, 'globalEE')
+// Only override the exposed event emitter if one has not already been exposed
+const nr = gosNREUM()
+if (!nr.ee) {
   nr.ee = globalInstance
 }
 
-export { globalInstance as ee }
-
-function EventContext () { }
+export { globalInstance as ee, contextId }
 
 function ee (old, debugId) {
   var handlers = {}
@@ -65,9 +62,9 @@ function ee (old, debugId) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ctxId, getNewContext)
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId))
     } else {
-      return getNewContext()
+      return new EventContext(contextId)
     }
   }
 
@@ -119,17 +116,18 @@ function ee (old, debugId) {
   }
 
   function bufferEventsByGroup (types, group) {
-    var eventBuffer = getBuffer()
+    const eventBuffer = getBuffer()
+    group = group || 'feature'
 
     // do not buffer events if agent has been aborted
     if (emitter.aborted) return
-    mapOwn(types, function (i, type) {
-      group = group || 'feature'
-      bufferGroupMap[type] = group
-      if (!(group in eventBuffer)) {
-        eventBuffer[group] = []
-      }
-    })
+    Object.entries(types || {})
+      .forEach(([_, type]) => {
+        bufferGroupMap[type] = group
+        if (!(group in eventBuffer)) {
+          eventBuffer[group] = []
+        }
+      })
   }
 
   function isBuffering (type) {
@@ -144,15 +142,6 @@ function ee (old, debugId) {
   }
 }
 
-// get context object from store object, or create if does not exist
-export function getOrSetContext (obj) {
-  return getOrSet(obj, ctxId, getNewContext)
-}
-
-function getNewContext () {
-  return new EventContext()
-}
-
 function abort () {
   globalInstance.aborted = true
   globalInstance.backlog = {}

package/src/common/event-emitter/event-context.js

@@ -0,0 +1,5 @@
+export class EventContext {
+  constructor (contextId) {
+    this.contextId = contextId
+  }
+}

package/src/common/harvest/harvest.js

@@ -47,7 +47,8 @@ export class Harvest extends SharedContext {
   sendX (spec = {}) {
     const submitMethod = submitData.getSubmitMethod({ isFinalHarvest: spec.opts?.unload })
     const options = {
-      retry: !spec.opts?.unload && submitMethod === submitData.xhr
+      retry: !spec.opts?.unload && submitMethod === submitData.xhr,
+      isFinalHarvest: spec.opts?.unload === true
     }
     const payload = this.createPayload(spec.endpoint, options)
     const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this)

package/src/common/harvest/harvest.test.js

@@ -53,7 +53,7 @@ describe('sendX', () => {
 
     harvestInstance.sendX(spec)
 
-    expect(harvestInstance.createPayload).toHaveBeenCalledWith(spec.endpoint, { retry: true })
+    expect(harvestInstance.createPayload).toHaveBeenCalledWith(spec.endpoint, { retry: true, isFinalHarvest: false })
   })
 
   test('should not use obfuscateAndSend', async () => {

package/src/common/ids/__mocks__/bundle-id.js

@@ -0,0 +1,2 @@
+import { faker } from '@faker-js/faker'
+export const bundleId = faker.datatype.uuid()

package/src/common/ids/__mocks__/unique-id.js

@@ -0,0 +1,17 @@
+import { faker } from '@faker-js/faker'
+
+export function generateUuid () {
+  return faker.datatype.uuid()
+}
+
+export function generateRandomHexString (length) {
+  return faker.datatype.hexadecimal({ length, prefix: '' })
+}
+
+export function generateSpanId () {
+  return generateRandomHexString(16)
+}
+
+export function generateTraceId () {
+  return generateRandomHexString(32)
+}

package/src/common/ids/bundle-id.js

@@ -0,0 +1,13 @@
+/**
+ * @file Contains a unique identifier for the running agent bundle
+ * when loaded.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+
+import { generateUuid } from './unique-id'
+
+/**
+ * Provides a unique id for the current agent bundle
+ */
+export const bundleId = generateUuid()

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/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/window/__mocks__/nreum.js

@@ -0,0 +1,10 @@
+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(() => ({}))

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)
 

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

@@ -7,7 +7,9 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-export const flag = 'nr@original'
+import { bundleId } from '../ids/bundle-id'
+
+export const flag = `nr@original:${bundleId}`
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -107,26 +109,24 @@ export function createWrapperWithEmitter (emitter, always) {
 
   /**
    * Creates wrapper functions around each of an array of methods on a specified object.
-   * @param {Object} obj - The object to which the specified methods belong.
-   * @param {string[]} methods - An array of method names to be wrapped.
-   * @param {string} [prefix=''] - A prefix to add to the names of emitted events. If `-` is the first character, also
-   *     adds the method name before the prefix.
-   * @param {function|object} [getContext] - The function or object that will serve as the 'this' context for handlers
-   *     of events emitted by this wrapper.
-   * @param {boolean} [bubble=false] - If `true`, emitted events should also bubble up to the old emitter upon which
-   *     the `emitter` in the current scope was based (if it defines one).
+   * @param {Object} obj The object to which the specified methods belong.
+   * @param {string[]} methods An array of method names to be wrapped.
+   * @param {string} [prefix=''] A prefix to add to the names of emitted events. If `-` is the first character, also
+   * adds the method name before the prefix.
+   * @param {function|object} [getContext] The function or object that will serve as the 'this' context for handlers
+   * of events emitted by this wrapper.
+   * @param {boolean} [bubble=false] If `true`, emitted events should also bubble up to the old emitter upon which
+   * the `emitter` in the current scope was based (if it defines one).
    */
   function inPlace (obj, methods, prefix, getContext, bubble) {
     if (!prefix) prefix = ''
+
     // If prefix starts with '-' set this boolean to add the method name to the prefix before passing each one to wrap.
-    var prependMethodPrefix = (prefix.charAt(0) === '-')
-    var fn
-    var method
-    var i
+    const prependMethodPrefix = (prefix.charAt(0) === '-')
 
-    for (i = 0; i < methods.length; i++) {
-      method = methods[i]
-      fn = obj[method]
+    for (let i = 0; i < methods.length; i++) {
+      const method = methods[i]
+      const fn = obj[method]
 
       // Unless fn is both wrappable and unwrapped, bail so we don't add extra properties with undefined values.
       if (notWrappable(fn)) continue
@@ -217,31 +217,3 @@ function copy (from, to, emitter) {
 function notWrappable (fn) {
   return !(fn && fn instanceof Function && fn.apply && !fn[flag])
 }
-
-/**
- * Creates a wrapped version of a function using a specified wrapper function. The new wrapped function references the
- * original function. Also copies the properties of the original function to the wrapped function.
- * @param {function} fn - A function to be wrapped.
- * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
- *     to the higher order function as an argument.
- * @returns {function} A wrapped function with an internal reference to the original function.
- */
-export function wrapFunction (fn, wrapper) {
-  var wrapped = wrapper(fn)
-  wrapped[flag] = fn
-  copy(fn, wrapped, ee)
-  return wrapped
-}
-
-/**
- * Replaces a function with a wrapped version of itself. To preserve object references, rather than taking the function
- * itself as an argument, takes the object on which the particular named function is a property.
- * @param {Object} obj - The object on which the named function is a property.
- * @param {string} fnName - The name of the function to be wrapped.
- * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
- *     to the higher order function as an argument.
- */
-export function wrapInPlace (obj, fnName, wrapper) {
-  var fn = obj[fnName]
-  obj[fnName] = wrapFunction(fn, wrapper)
-}

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

@@ -9,8 +9,7 @@
 
 import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
-import { originals } from '../config/config'
-import { isBrowserScope } from '../constants/runtime'
+import { globalScope, isBrowserScope } from '../constants/runtime'
 
 const wrapped = {}
 
@@ -30,7 +29,7 @@ export function wrapMutation (sharedEE) {
   wrapped[ee.debugId] = true // otherwise, first feature to wrap mutations
 
   var wrapFn = wfn(ee)
-  var OriginalObserver = originals.MO
+  var OriginalObserver = globalScope.MutationObserver
 
   if (OriginalObserver) {
     window.MutationObserver = function WrappedMutationObserver (cb) {

package/src/common/wrap/{wrap-promise.test.js → wrap-promise.component-test.js}

@@ -1,35 +1,5 @@
 import { faker } from '@faker-js/faker'
 import { globalScope } from '../constants/runtime'
-import { originals } from '../config/config'
-
-jest.mock('./wrap-function', () => ({
-  __esModule: true,
-  createWrapperWithEmitter: jest.fn(() => (fn) => (...args) => {
-    return fn.apply(null, args)
-  })
-}))
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  getOrSetContext: jest.fn(() => ({})),
-  ee: {
-    get: jest.fn((name) => ({
-      debugId: name,
-      on: jest.fn(),
-      context: jest.fn(() => ({})),
-      emit: jest.fn()
-    }))
-  }
-}))
-jest.mock('../config/config', () => ({
-  __esModule: true,
-  originals: {}
-}))
-jest.mock('../constants/runtime', () => ({
-  __esModule: true,
-  globalScope: {
-    NREUM: {}
-  }
-}))
 
 let promiseConstructorCalls
 
@@ -38,7 +8,7 @@ beforeEach(async () => {
 
   // Proxy the global Promise to prevent the wrapping from
   // messing with Jest internal promises
-  originals.PR = new Proxy(class extends Promise {}, {
+  window.Promise = new Proxy(class extends Promise {}, {
     construct (target, args) {
       promiseConstructorCalls.push(args)
 
@@ -57,7 +27,7 @@ test('should wrap promise constructor', async () => {
   const promiseInstance = new globalScope.Promise(jest.fn())
 
   expect(promiseInstance).toBeInstanceOf(Promise)
-  expect(promiseConstructorCalls.length).toEqual(1)
+  expect(promiseConstructorCalls.length).toBeGreaterThan(0)
   expect(globalScope.Promise.toString()).toMatch(/\[native code\]/)
   expect(globalScope.Promise.name).toEqual('Promise')
 })

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

@@ -8,8 +8,7 @@
  */
 
 import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function'
-import { ee as baseEE, getOrSetContext } from '../event-emitter/contextual-ee'
-import { originals } from '../config/config'
+import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
 
 const wrapped = {}
@@ -29,9 +28,9 @@ export function wrapPromise (sharedEE) {
   if (wrapped[promiseEE.debugId]) return promiseEE
   wrapped[promiseEE.debugId] = true // otherwise, first feature to wrap promise
 
-  var getContext = getOrSetContext
+  var getContext = promiseEE.context
   var promiseWrapper = wrapFn(promiseEE)
-  var prevPromiseObj = originals.PR
+  var prevPromiseObj = globalScope.Promise
 
   if (prevPromiseObj) { // ensure there's a Promise API (native or otherwise) to even wrap
     wrap()