@newrelic/browser-agent 0.1.231 → 1.232.1

package/src/common/timer/timer.js

@@ -0,0 +1,31 @@
+
+export class Timer {
+  constructor (opts, ms) {
+    if (!opts.onEnd) throw new Error('onEnd handler is required')
+    if (!ms) throw new Error('ms duration is required')
+    this.onEnd = opts.onEnd
+    this.initialMs = ms
+    this.startTimestamp = Date.now()
+
+    this.timer = this.create(this.onEnd, ms)
+  }
+
+  create (cb, ms) {
+    if (this.timer) this.clear()
+    return setTimeout(() => cb ? cb() : this.onEnd(), ms || this.initialMs)
+  }
+
+  clear () {
+    clearTimeout(this.timer)
+    this.timer = null
+  }
+
+  end () {
+    this.clear()
+    this.onEnd()
+  }
+
+  isValid () {
+    return this.initialMs - (Date.now() - this.startTimestamp) > 0
+  }
+}

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

@@ -0,0 +1,100 @@
+import { Timer } from './timer'
+
+jest.useFakeTimers()
+
+let now
+
+beforeEach(() => {
+  now = Date.now()
+  jest.setSystemTime(now)
+})
+
+afterEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('required keys are enforced', () => {
+    try {
+      new Timer({}, 100)
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'))
+    }
+
+    try {
+      new Timer({ onEnd: jest.fn() })
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'))
+    }
+  })
+})
+
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.timer).toBeTruthy()
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.runOnlyPendingTimers()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('Create can fallback to use defaults', () => {
+    let called = 0
+    const timer1 = new Timer({ onEnd: jest.fn() }, 100)
+    timer1.create()
+
+    const timer2 = new Timer({ onEnd: jest.fn() }, 100)
+    timer2.create(timer2.onEnd)
+
+    const timer3 = new Timer({ onEnd: jest.fn() }, 100)
+    timer3.create(undefined, 100)
+
+    jest.runAllTimers(200)
+
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.clear()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.end()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.isValid()).toEqual(true)
+    timer.startTimestamp -= 100
+    expect(timer.isValid()).toEqual(false)
+  })
+})

package/src/common/unload/eol.js

@@ -4,7 +4,7 @@
  */
 import { ffVersion } from '../browser-version/firefox-version'
 import { windowAddEventListener } from '../event-listener/event-listener-opts'
-import { single } from '../util/single'
+import { single } from '../util/invoke'
 import { globalScope, isWorkerScope, isBrowserScope } from '../util/global-scope'
 import { subscribeToVisibilityChange } from '../window/page-visibility'
 

package/src/common/url/canonicalize-url.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { initialLocation } from '../util/global-scope'
+import { cleanURL } from './clean-url'
+
+/**
+ * Converts a URL to its basic form without a query string or fragment. If the resulting URL is the same as the
+ * loader's origin URL, returns '<inline>'.
+ * @param {string} url - The URL to be canonicalized.
+ * @param {string} loaderOriginUrl - The origin URL of the agent loader, used for inline detection.
+ * @returns {string} The canonicalized URL, or '<inline>' if the URL matches the loader origin URL.
+ */
+export function canonicalizeUrl (url) {
+  if (typeof url !== 'string') return ''
+
+  const cleanedUrl = cleanURL(url)
+  const cleanedGlobalScopeUrl = cleanURL(initialLocation)
+
+  // If the URL matches the origin URL of the loader, we assume it originated within an inline script.
+  if (cleanedUrl === cleanedGlobalScopeUrl) {
+    return '<inline>'
+  } else {
+    return cleanedUrl
+  }
+}

package/src/common/url/canonicalize-url.test.js

@@ -0,0 +1,34 @@
+afterEach(() => {
+  jest.resetModules()
+})
+
+test.each([null, undefined, 34])('returns empty string when url argument is %s', async (url) => {
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl(url)).toEqual('')
+})
+
+test('strips URLs of query strings and fragments', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://different-domain.com/'
+  }))
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl('http://example.com/path?query=string#fragment')).toBe('http://example.com/path')
+  expect(canonicalizeUrl('https://www.example.com/path/to/file.html?param=value')).toBe('https://www.example.com/path/to/file.html')
+  expect(canonicalizeUrl('https://www.example.com/?param=value#fragment')).toBe('https://www.example.com/')
+})
+
+test('returns <inline> when matching the page URL of the loader', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }))
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl('http://example.com/')).toEqual('<inline>')
+})
+
+test('does not identify sub-paths of the loader origin as <inline>', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }))
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl('http://example.com/path/to/script.js')).not.toEqual('<inline>')
+})

package/src/common/url/clean-url.js

@@ -3,8 +3,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var withHash = /([^?#]*)[^#]*(#[^?]*|$).*/
-var withoutHash = /([^?#]*)().*/
+var patternWithHash = /([^?#]*)[^#]*(#[^?]*|$).*/
+var patternWithoutHash = /([^?#]*)().*/
+
+/**
+ * Cleans a URL by removing the query string and fragment (hash portion).
+ * @param {string} url - The original URL to be cleaned.
+ * @param {boolean} [keepHash=false] - Whether to preserve the hash portion of the URL.
+ * @returns {string} The cleaned URL.
+ */
 export function cleanURL (url, keepHash) {
-  return url.replace(keepHash ? withHash : withoutHash, '$1$2')
+  return url.replace(keepHash ? patternWithHash : patternWithoutHash, '$1$2')
 }

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

@@ -5,6 +5,12 @@
 
 import { stringify } from './stringify'
 
+/**
+ * Returns the size of the provided data. Designed for measuring XHR responses.
+ *
+ * @param {*} data - The data to be measured.
+ * @returns {(number|undefined)} - The size of the data or undefined if size cannot be determined.
+ */
 export function dataSize (data) {
   if (typeof data === 'string' && data.length) return data.length
   if (typeof data !== 'object') return undefined

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

@@ -0,0 +1,50 @@
+import { dataSize } from './data-size'
+
+describe('dataSize', () => {
+  test('returns length of string', () => {
+    const str = 'Hello, world!'
+    expect(dataSize(str)).toBe(str.length)
+  })
+
+  test('returns undefined for non-object, number, or empty string', () => {
+    expect(dataSize(Infinity)).toBeUndefined()
+    expect(dataSize(12345)).toBeUndefined() // might not actually be by design, but this is how it works today
+    expect(dataSize('')).toBeUndefined()
+  })
+
+  test('returns byte length of ArrayBuffer object', () => {
+    const buffer = new ArrayBuffer(8)
+    expect(dataSize(buffer)).toBe(8)
+  })
+
+  test('returns size of Blob object', () => {
+    const blob = new Blob(['Hello, world!'], { type: 'text/plain' })
+    expect(dataSize(blob)).toBe(blob.size)
+  })
+
+  test('returns undefined for FormData object', () => {
+    const formData = new FormData()
+    expect(dataSize(formData)).toBeUndefined()
+  })
+
+  test('returns length of JSON string representation of object', () => {
+    const obj = {
+      str: 'Hello, world!',
+      num: 12345,
+      nestedObj: {
+        arr: [1, 2, 3]
+      }
+    }
+    const expectedSize = JSON.stringify(obj).length
+    expect(dataSize(obj)).toBe(expectedSize)
+  })
+
+  test('returns undefined for object with toJSON method that throws an error', () => {
+    const obj = {
+      toJSON: () => {
+        throw new Error('Error in toJSON')
+      }
+    }
+    expect(dataSize(obj)).toBeUndefined()
+  })
+})

package/src/common/util/global-scope.js

@@ -20,6 +20,8 @@ export let globalScope = (() => {
   throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".')
 })()
 
+export const initialLocation = '' + globalScope.location
+
 /**
  * The below methods are only used for testing and should be removed once the
  * reliant tests are moved to Jest.

package/src/common/util/invoke.js

@@ -0,0 +1,55 @@
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once within a given timeout.
+ *
+ * If `wait` is `0`, the function will be invoked during the next tick.
+ * If `options.leading` is false or not provided, the function will be invoked
+ * N milliseconds after the last invocation of the returned function where
+ * N is the `timeout` value.
+ * If `options.leading` is true, the function will be invoked immediately upon
+ * the first invocation of the returned function and not again for N milliseconds
+ * where N is the `timeout` value.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once within a given timeout period.
+ * @param {number} timeout Time in milliseconds that the function should only be invoked
+ * once within.
+ * @param {object} options Debounce options
+ * @param {boolean} options.leading Forces the function to be invoked on the first
+ * invocation of the returned function instead of N milliseconds after the last
+ * invocation.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once within the given timeout.
+ */
+export function debounce (func, timeout = 500, options = {}) {
+  const leading = options?.leading || false
+  let timer
+  return (...args) => {
+    if (leading && timer === undefined) {
+      func.apply(this, args)
+      timer = setTimeout(() => timer = clearTimeout(timer), timeout)
+    }
+
+    if (!leading) {
+      clearTimeout(timer)
+      timer = setTimeout(() => { func.apply(this, args) }, timeout)
+    }
+  }
+}
+
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once.
+ */
+export function single (func) {
+  let called = false
+  return (...args) => {
+    if (!called) {
+      called = true
+      func.apply(this, args)
+    }
+  }
+}

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

@@ -0,0 +1,65 @@
+import { debounce, single } from './invoke'
+
+jest.useFakeTimers()
+
+describe('debounce', () => {
+  test('should run the supplied function after 100ms', () => {
+    let mockCallback = jest.fn()
+
+    let debouncedMethod = debounce(mockCallback, 100)
+    execFnTimes(debouncedMethod, 100)
+
+    expect(mockCallback).not.toHaveBeenCalled()
+
+    jest.advanceTimersByTime(1000)
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+  })
+
+  test('should rerun the supplied function when called again after 100ms', () => {
+    let mockCallback = jest.fn()
+
+    let debouncedMethod = debounce(mockCallback, 100)
+
+    execFnTimes(debouncedMethod, 100)
+    jest.advanceTimersByTime(200)
+    execFnTimes(debouncedMethod, 100)
+    jest.advanceTimersByTime(2000)
+
+    expect(mockCallback).toHaveBeenCalledTimes(2)
+  })
+
+  test('should run the supplied function on the first event and debounce subsequent events', () => {
+    let mockCallback = jest.fn()
+
+    let debouncedMethod = debounce(mockCallback, 100, { leading: true })
+
+    execFnTimes(debouncedMethod, 100)
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+
+    jest.advanceTimersByTime(200)
+
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+
+    execFnTimes(debouncedMethod, 100)
+    jest.advanceTimersByTime(200)
+
+    expect(mockCallback).toHaveBeenCalledTimes(2)
+  })
+})
+
+describe('single', () => {
+  test('should run the supplied function only once', () => {
+    let mockCallback = jest.fn()
+
+    let singleMethod = single(mockCallback, 100)
+    execFnTimes(singleMethod, 100)
+
+    expect(mockCallback).toHaveBeenCalledTimes(1)
+  })
+})
+
+function execFnTimes (fn, count) {
+  for (let i = 0; i < count; i++) {
+    fn()
+  }
+}

package/src/common/util/obfuscate.js

@@ -8,10 +8,6 @@ var fileProtocolRule = {
   replacement: 'file://OBFUSCATED'
 }
 export class Obfuscator extends SharedContext {
-  constructor (parent) {
-    super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
-  }
-
   shouldObfuscate () {
     return getRules(this.sharedContext.agentIdentifier).length > 0
   }

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

@@ -10,8 +10,8 @@ import { documentAddEventListener } from '../event-listener/event-listener-opts'
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-export function subscribeToVisibilityChange (cb, toHiddenOnly = false) {
-  documentAddEventListener('visibilitychange', handleVisibilityChange)
+export function subscribeToVisibilityChange (cb, toHiddenOnly = false, capture, abortSignal) {
+  documentAddEventListener('visibilitychange', handleVisibilityChange, capture, abortSignal)
   return
 
   function handleVisibilityChange () {

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

@@ -7,7 +7,6 @@
  * This module is used by: ajax, spa.
  */
 import { ee as baseEE } from '../event-emitter/contextual-ee'
-import slice from 'lodash._slice'
 import { globalScope } from '../util/global-scope'
 import { flag } from './wrap-function'
 
@@ -71,7 +70,7 @@ export function wrapFetch (sharedEE) {
     var fn = target[name]
     if (typeof fn === 'function') {
       target[name] = function () {
-        var args = slice(arguments)
+        var args = Array.from(arguments)
 
         var ctx = {}
         // we are wrapping args in an array so we can preserve the reference

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

@@ -7,7 +7,6 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-import slice from 'lodash._slice'
 export const flag = 'nr@original'
 
 /**
@@ -77,7 +76,7 @@ export function createWrapperWithEmitter (emitter, always) {
 
       try {
         originalThis = this
-        args = slice(arguments)
+        args = Array.from(arguments)
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis)

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

@@ -26,7 +26,7 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
  * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
  * @returns {Object} Scoped event emitter with a debug ID of `timer`.
  */
-//eslint-disable-next-line
+// eslint-disable-next-line
 export function wrapTimer(sharedEE) {
   const ee = scopedEE(sharedEE)
 

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

@@ -9,13 +9,13 @@ import { handle } from '../../../common/event-emitter/handle'
 import { getConfigurationValue, getInfo } from '../../../common/config/config'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list'
-import { AggregateBase } from '../../utils/aggregate-base'
 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'
 
-export class Aggregate extends AggregateBase {
+export class Aggregate extends FeatureBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)

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

@@ -99,7 +99,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
 
   function onOpenXhrEnd (args, xhr) {
     var loader_config = getLoaderConfig(agentIdentifier)
-    if ('xpid' in loader_config && this.sameOrigin) {
+    if (loader_config.xpid && this.sameOrigin) {
       xhr.setRequestHeader('X-NewRelic-ID', loader_config.xpid)
     }
 

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

@@ -3,11 +3,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var canonicalFunctionNameRe = /([a-z0-9]+)$/i
-export function canonicalFunctionName (orig) {
-  if (!orig) return
+const canonicalFunctionNameRe = /([a-z0-9]+)$/i
 
-  var match = orig.match(canonicalFunctionNameRe)
+/**
+ * Given a function name string, extracts only an alphanumeric segment at the end of the string (if one exists).
+ * This is useful for stack traces, where functions might not be named (e.g., anonymous, computed).
+ *
+ * @param {string} functionNameString - The original function name string.
+ * @returns {string|undefined} The canonical function name, or undefined if the input is falsy or no alphanumeric segments are found.
+ */
+export function canonicalFunctionName (functionNameString) {
+  if (!functionNameString) return
+
+  const match = functionNameString.match(canonicalFunctionNameRe)
   if (match) return match[1]
 
   return