@newrelic/browser-agent 1.237.1 → 1.239.0

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-jsonp.js

@@ -122,7 +122,7 @@ export function wrapJsonP (sharedEE) {
       }
     }
     return {
-      key: key,
+      key,
       parent: window
     }
   }

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()

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

@@ -11,7 +11,6 @@ import { wrapEvents } from './wrap-events'
 import { ee as contextualEE } from '../event-emitter/contextual-ee'
 import { eventListenerOpts } from '../event-listener/event-listener-opts'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
-import { originals } from '../config/config'
 import { globalScope } from '../constants/runtime'
 import { warn } from '../util/console'
 
@@ -37,37 +36,33 @@ export function wrapXhr (sharedEE) {
   wrapEvents(baseEE) // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = wfn(ee)
 
-  var OrigXHR = originals.XHR
-  var MutationObserver = originals.MO
-  var Promise = originals.PR
-  var setImmediate = originals.SI
+  var OrigXHR = globalScope.XMLHttpRequest
+  var MutationObserver = globalScope.MutationObserver
+  var Promise = globalScope.Promise
+  var setImmediate = globalScope.setInterval
 
   var READY_STATE_CHANGE = 'readystatechange'
 
   var handlers = ['onload', 'onerror', 'onabort', 'onloadstart', 'onloadend', 'onprogress', 'ontimeout']
   var pendingXhrs = []
 
-  var activeListeners = globalScope.XMLHttpRequest.listeners
-
   var XHR = globalScope.XMLHttpRequest = newXHR
 
   function newXHR (opts) {
-    var xhr = new OrigXHR(opts)
-    this.listeners = activeListeners ? [...activeListeners, intercept] : [intercept]
-    function intercept () {
+    const xhr = new OrigXHR(opts)
+    const context = ee.context(xhr)
+
+    try {
+      ee.emit('new-xhr', [xhr], context)
+      xhr.addEventListener(READY_STATE_CHANGE, wrapXHR(context), eventListenerOpts(false))
+    } catch (e) {
+      warn('An error occurred while intercepting XHR', e)
       try {
-        ee.emit('new-xhr', [xhr], xhr)
-        xhr.addEventListener(READY_STATE_CHANGE, wrapXHR, eventListenerOpts(false))
-      } catch (e) {
-        warn('An error occured while intercepting XHR', e)
-        try {
-          ee.emit('internal-error', [e])
-        } catch (err) {
-          // do nothing
-        }
+        ee.emit('internal-error', [e])
+      } catch (err) {
+        // do nothing
       }
     }
-    this.listeners.forEach(listener => listener())
     return xhr
   }
 
@@ -87,16 +82,17 @@ export function wrapXhr (sharedEE) {
     wrapFn.inPlace(xhr, ['onreadystatechange'], 'fn-', getObject)
   }
 
-  function wrapXHR () {
-    var xhr = this
-    var ctx = ee.context(xhr)
+  function wrapXHR (ctx) {
+    return function () {
+      var xhr = this
 
-    if (xhr.readyState > 3 && !ctx.resolved) {
-      ctx.resolved = true
-      ee.emit('xhr-resolved', [], xhr)
-    }
+      if (xhr.readyState > 3 && !ctx.resolved) {
+        ctx.resolved = true
+        ee.emit('xhr-resolved', [], xhr)
+      }
 
-    wrapFn.inPlace(xhr, handlers, 'fn-', getObject)
+      wrapFn.inPlace(xhr, handlers, 'fn-', getObject)
+    }
   }
 
   // Wrapping the onreadystatechange property of XHRs takes some special tricks.

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

@@ -10,7 +10,6 @@ import { getConfiguration, getInfo, getRuntime } from '../../../common/config/co
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list'
 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 { AggregateBase } from '../../utils/aggregate-base'
@@ -24,7 +23,7 @@ export class Aggregate extends AggregateBase {
 
     register('xhr', storeXhr, this.featureName, this.ee)
     if (!allAjaxIsEnabled) {
-      drain(this.agentIdentifier, this.featureName)
+      this.drain()
       return // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
     }
 
@@ -66,8 +65,7 @@ export class Aggregate extends AggregateBase {
 
     ee.on(`drain-${this.featureName}`, () => { scheduler.startTimer(harvestTimeSeconds) })
 
-    drain(this.agentIdentifier, this.featureName)
-    return
+    this.drain()
 
     function storeXhr (params, metrics, startTime, endTime, type) {
       metrics.time = startTime
@@ -105,9 +103,9 @@ export class Aggregate extends AggregateBase {
         path: params.pathname,
         requestSize: metrics.txSize,
         responseSize: metrics.rxSize,
-        type: type,
-        startTime: startTime,
-        endTime: endTime,
+        type,
+        startTime,
+        endTime,
         callbackDuration: metrics.cbTime
       }
 

package/src/features/ajax/instrument/distributed-tracing.js

@@ -11,10 +11,6 @@ import { stringify } from '../../../common/util/stringify'
 export class DT {
   constructor (agentIdentifier) {
     this.agentIdentifier = agentIdentifier
-    // Binds this class instance context to the following fn used in an external module (exported);
-    //  Alternatively, can make them class field arrow functions, but requires experimental features/plugin for eslint.
-    this.generateTracePayload = this.generateTracePayload.bind(this)
-    this.shouldGenerateTrace = this.shouldGenerateTrace.bind(this)
   }
 
   generateTracePayload (parsedOrigin) {
@@ -22,14 +18,14 @@ export class DT {
       return null
     }
 
-    var loader_config = getLoaderConfig(this.agentIdentifier)
-    if (!loader_config) {
+    var loaderConfig = getLoaderConfig(this.agentIdentifier)
+    if (!loaderConfig) {
       return null
     }
 
-    var accountId = (loader_config.accountID || '').toString() || null
-    var agentId = (loader_config.agentID || '').toString() || null
-    var trustKey = (loader_config.trustKey || '').toString() || null
+    var accountId = (loaderConfig.accountID || '').toString() || null
+    var agentId = (loaderConfig.agentID || '').toString() || null
+    var trustKey = (loaderConfig.trustKey || '').toString() || null
 
     if (!accountId || !agentId) {
       return null
@@ -40,9 +36,9 @@ export class DT {
     var timestamp = Date.now()
 
     var payload = {
-      spanId: spanId,
-      traceId: traceId,
-      timestamp: timestamp
+      spanId,
+      traceId,
+      timestamp
     }
 
     if (parsedOrigin.sameOrigin ||