@newrelic/browser-agent 1.238.0 → 1.239.0

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/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__/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

@@ -7,4 +7,6 @@ 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(() => ({}))
+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-jsonp.js

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

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

@@ -18,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
@@ -36,9 +36,9 @@ export class DT {
     var timestamp = Date.now()
 
     var payload = {
-      spanId: spanId,
-      traceId: traceId,
-      timestamp: timestamp
+      spanId,
+      traceId,
+      timestamp
     }
 
     if (parsedOrigin.sameOrigin ||

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

@@ -34,6 +34,29 @@ export class Instrument extends InstrumentBase {
     this.dt = new DT(agentIdentifier)
 
     this.handler = (type, args, ctx, group) => handle(type, args, ctx, group, this.ee)
+
+    // this is a best (but imperfect) effort at capturing AJAX calls that may have fired before the agent was instantiated
+    // this could happen because the agent was "improperly" set up (ie, not at the top of the head) or
+    // because it was deferred from loading in some way -- e.g. 'deferred' script loading tags or other lazy-loading techniques
+    //
+    // it is "imperfect" because we cannot capture the following with the API vs wrapping the events directly:
+    // * requestBodySize - (txSize -- request body size)
+    // * method - request type (GET, POST, etc)
+    // * callbackDuration - (cbTime -- sum of resulting callback time)
+    try {
+      const initiators = { xmlhttprequest: 'xhr', fetch: 'fetch', beacon: 'beacon' }
+      globalScope?.performance?.getEntriesByType('resource').forEach(resource => {
+        if (resource.initiatorType in initiators && resource.responseStatus !== 0) {
+          const params = { status: resource.responseStatus }
+          const metrics = { rxSize: resource.transferSize, duration: Math.floor(resource.duration), cbTime: 0 }
+          addUrl(params, resource.name)
+          this.handler('xhr', [params, metrics, resource.startTime, resource.responseEnd, initiators[resource.initiatorType]], undefined, FEATURE_NAMES.ajax)
+        }
+      })
+    } catch (err) {
+      // do nothing
+    }
+
     wrapFetch(this.ee)
     wrapXhr(this.ee)
     subscribeToEvents(agentIdentifier, this.ee, this.handler, this.dt)
@@ -97,9 +120,9 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
   }
 
   function onOpenXhrEnd (args, xhr) {
-    var loader_config = getLoaderConfig(agentIdentifier)
-    if (loader_config.xpid && this.sameOrigin) {
-      xhr.setRequestHeader('X-NewRelic-ID', loader_config.xpid)
+    var loaderConfig = getLoaderConfig(agentIdentifier)
+    if (loaderConfig.xpid && this.sameOrigin) {
+      xhr.setRequestHeader('X-NewRelic-ID', loaderConfig.xpid)
     }
 
     var payload = dt.generateTracePayload(this.parsedOrigin)
@@ -312,7 +335,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
 
   // we capture failed call as status 0, the actual error is ignored
   // eslint-disable-next-line handle-callback-err
-  function onFetchDone (err, res) {
+  function onFetchDone (_, res) {
     this.endTime = now()
     if (!this.params) {
       this.params = {}
@@ -360,19 +383,6 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
     handler('xhr', [params, metrics, this.startTime, this.endTime, 'xhr'], this, FEATURE_NAMES.ajax)
   }
 
-  function addUrl (ctx, url) {
-    var parsed = parseUrl(url)
-    var params = ctx.params
-
-    params.hostname = parsed.hostname
-    params.port = parsed.port
-    params.protocol = parsed.protocol
-    params.host = parsed.hostname + ':' + parsed.port
-    params.pathname = parsed.pathname
-    ctx.parsedOrigin = parsed
-    ctx.sameOrigin = parsed.sameOrigin
-  }
-
   function captureXhrData (ctx, xhr) {
     ctx.params.status = xhr.status
 
@@ -389,3 +399,16 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
     ctx.loadCaptureCalled = true
   }
 }
+
+function addUrl (ctx, url) {
+  var parsed = parseUrl(url)
+  var params = ctx.params || ctx
+
+  params.hostname = parsed.hostname
+  params.port = parsed.port
+  params.protocol = parsed.protocol
+  params.host = parsed.hostname + ':' + parsed.port
+  params.pathname = parsed.pathname
+  ctx.parsedOrigin = parsed
+  ctx.sameOrigin = parsed.sameOrigin
+}

package/src/features/jserrors/aggregate/canonical-function-name.js

@@ -17,6 +17,4 @@ export function canonicalFunctionName (functionNameString) {
 
   const match = functionNameString.match(canonicalFunctionNameRe)
   if (match) return match[1]
-
-  return
 }

package/src/features/jserrors/aggregate/compute-stack-trace.js

@@ -64,8 +64,8 @@ var debug = false
 var classNameRegex = /function (.+?)\s*\(/
 var chrome = /^\s*at (?:((?:\[object object\])?(?:[^(]*\([^)]*\))*[^()]*(?: \[as \S+\])?) )?\(?((?:file|http|https|chrome-extension):.*?)?:(\d+)(?::(\d+))?\)?\s*$/i
 var gecko = /^\s*(?:(\S*|global code)(?:\(.*?\))?@)?((?:file|http|https|chrome|safari-extension).*?):(\d+)(?::(\d+))?\s*$/i
-var chrome_eval = /^\s*at .+ \(eval at \S+ \((?:(?:file|http|https):[^)]+)?\)(?:, [^:]*:\d+:\d+)?\)$/i
-var ie_eval = /^\s*at Function code \(Function code:\d+:\d+\)\s*/i
+var chromeEval = /^\s*at .+ \(eval at \S+ \((?:(?:file|http|https):[^)]+)?\)(?:, [^:]*:\d+:\d+)?\)$/i
+var ieEval = /^\s*at Function code \(Function code:\d+:\d+\)\s*/i
 
 /**
  * Represents an error with a stack trace.
@@ -209,7 +209,7 @@ function getStackElement (line) {
     })
   }
 
-  if (line.match(chrome_eval) || line.match(ie_eval) || line === 'anonymous') {
+  if (line.match(chromeEval) || line.match(ieEval) || line === 'anonymous') {
     return { func: 'evaluated code' }
   }
 }
@@ -255,7 +255,7 @@ function computeStackTraceBySourceAndLine (ex) {
     mode: 'sourceline',
     name: className,
     message: ex.message,
-    stackString: stackString,
+    stackString,
     frames: [{
       url: canonicalUrl,
       line: ex.line,

package/src/features/jserrors/aggregate/compute-stack-trace.test.js

@@ -305,7 +305,7 @@ describe('errors without stack property and with line property', () => {
       line: 100,
       column: 200,
       stack: undefined,
-      sourceURL: sourceURL
+      sourceURL
     })
 
     mockGlobalScopeLocation(pageLocation)