@newrelic/browser-agent 1.232.0 → 1.233.0

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

@@ -41,27 +41,30 @@ describe('constructor', () => {
     expect(session).toMatchObject({
       agentIdentifier: expect.any(String),
       key: expect.any(String),
-      value: expect.any(String),
       expiresMs: expect.any(Number),
-      expiresAt: expect.any(Number),
       expiresTimer: expect.any(Object),
       inactiveMs: expect.any(Number),
-      inactiveAt: expect.any(Number),
       inactiveTimer: expect.any(Object),
       isNew: expect.any(Boolean),
-      sessionReplayActive: expect.any(Boolean),
-      sessionTraceActive: expect.any(Boolean),
-      storage: expect.any(Object)
+      storage: expect.any(Object),
+      state: expect.objectContaining({
+        value: expect.any(String),
+        expiresAt: expect.any(Number),
+        inactiveAt: expect.any(Number),
+        sessionReplay: expect.any(Number),
+        sessionTraceActive: expect.any(Boolean)
+      })
     })
   })
 
   test('can use sane defaults', () => {
     const session = new SessionEntity({ agentIdentifier, key })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -76,47 +79,47 @@ describe('constructor', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100 })
-    expect(session.expiresAt).toEqual(now + 100)
+    expect(session.state.expiresAt).toEqual(now + 100)
   })
 
   test('expiresAt is the correct future timestamp - existing session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity } })
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100, storageAPI: existingData })
-    expect(session.expiresAt).toEqual(now + 5000)
+    expect(session.state.expiresAt).toEqual(now + 5000)
   })
 
   test('expiresAt never expires if 0', () => {
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 0 })
-    expect(session.expiresAt).toEqual(Infinity)
+    expect(session.state.expiresAt).toEqual(Infinity)
   })
 
   test('inactiveAt is the correct future timestamp - new session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
-    expect(session.inactiveAt).toEqual(now + 100)
+    expect(session.state.inactiveAt).toEqual(now + 100)
   })
 
   test('inactiveAt is the correct future timestamp - existing session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity } })
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100, storageAPI: existingData })
-    expect(session.inactiveAt).toEqual(now + 5000)
+    expect(session.state.inactiveAt).toEqual(now + 5000)
   })
 
   test('inactiveAt never expires if 0', () => {
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 0 })
-    expect(session.inactiveAt).toEqual(Infinity)
+    expect(session.state.inactiveAt).toEqual(Infinity)
   })
 
   test('should handle isNew', () => {
     const newSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
     expect(newSession.isNew).toBeTruthy()
 
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity } })
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const existingSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10, storageAPI })
     expect(existingSession.isNew).toBeFalsy()
   })
@@ -125,11 +128,12 @@ describe('constructor', () => {
     // missing required fields
     const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { invalid_fields: true } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -139,11 +143,12 @@ describe('constructor', () => {
     jest.setSystemTime(now)
     const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now - 100, inactiveAt: Infinity } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -153,11 +158,12 @@ describe('constructor', () => {
     jest.setSystemTime(now)
     const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now - 100, expiresAt: Infinity } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
-    expect(session).toEqual(expect.objectContaining({
+    expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      updatedAt: expect.any(Number),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
@@ -169,10 +175,10 @@ describe('reset()', () => {
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
     const sessionVal = session.value
-    expect(session.value).toBeTruthy()
+    expect(session.state.value).toBeTruthy()
     session.reset()
-    expect(session.value).toBeTruthy()
-    expect(session.value).not.toEqual(sessionVal)
+    expect(session.state.value).toBeTruthy()
+    expect(session.state.value).not.toEqual(sessionVal)
   })
 
   test('custom data should be wiped on reset', () => {
@@ -180,12 +186,12 @@ describe('reset()', () => {
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
     session.syncCustomAttribute('test', 123)
-    expect(session.custom.test).toEqual(123)
+    expect(session.state.custom.test).toEqual(123)
     expect(session.read().custom.test).toEqual(123)
 
     // simulate a timer expiring
     session.reset()
-    expect(session.custom?.test).toEqual(undefined)
+    expect(session.state.custom?.test).toEqual(undefined)
     expect(session.read()?.custom?.test).toEqual(undefined)
   })
 })
@@ -199,13 +205,13 @@ describe('read()', () => {
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
-      sessionReplayActive: expect.any(Boolean),
+      sessionReplay: expect.any(Number),
       sessionTraceActive: expect.any(Boolean)
     }))
   })
 
   test('"pre-existing" sessions get data from read()', () => {
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity } })
+    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceActive: false, custom: {} } })
     const session = new SessionEntity({ agentIdentifier, key, storageAPI })
     expect(session.isNew).toBeFalsy()
     expect(session.read()).toEqual(expect.objectContaining({
@@ -219,20 +225,20 @@ describe('read()', () => {
 describe('write()', () => {
   test('write() sets data to top-level wrapper', () => {
     const session = new SessionEntity({ agentIdentifier, key })
-    expect(session.value).not.toEqual(value)
-    expect(session.expiresAt).not.toEqual(Infinity)
-    expect(session.inactiveAt).not.toEqual(Infinity)
-    session.write({ value, expiresAt: Infinity, inactiveAt: Infinity })
-    expect(session.value).toEqual(value)
-    expect(session.expiresAt).toEqual(Infinity)
-    expect(session.inactiveAt).toEqual(Infinity)
+    expect(session.state.value).not.toEqual(value)
+    expect(session.state.expiresAt).not.toEqual(Infinity)
+    expect(session.state.inactiveAt).not.toEqual(Infinity)
+    session.write({ ...session.state, value, expiresAt: Infinity, inactiveAt: Infinity })
+    expect(session.state.value).toEqual(value)
+    expect(session.state.expiresAt).toEqual(Infinity)
+    expect(session.state.inactiveAt).toEqual(Infinity)
   })
 
   test('write() sets data that read() can access', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key })
-    session.write({ value, expiresAt: now + 100, inactiveAt: now + 100 })
+    session.write({ ...session.state, value, expiresAt: now + 100, inactiveAt: now + 100 })
     const read = session.read()
     expect(read.value).toEqual(value)
     expect(read.expiresAt).toEqual(now + 100)
@@ -259,30 +265,30 @@ describe('refresh()', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
-    expect(session.inactiveAt).toEqual(now + 100)
+    expect(session.state.inactiveAt).toEqual(now + 100)
     jest.setSystemTime(now + 1000)
     session.refresh()
-    expect(session.inactiveAt).toEqual(now + 100 + 1000)
+    expect(session.state.inactiveAt).toEqual(now + 100 + 1000)
   })
 
   test('refresh resets the entity if expiresTimer is invalid', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, value })
-    expect(session.value).toEqual(value)
-    session.write({ ...session.read(), expiresAt: now - 1 })
+    expect(session.state.value).toEqual(value)
+    session.write({ ...session.state, expiresAt: now - 1 })
     session.refresh()
-    expect(session.value).not.toEqual(value)
+    expect(session.state.value).not.toEqual(value)
   })
 
   test('refresh resets the entity if inactiveTimer is invalid', () => {
     const now = Date.now()
     jest.setSystemTime(now)
     const session = new SessionEntity({ agentIdentifier, key, value })
-    expect(session.value).toEqual(value)
-    session.write({ ...session.read(), inactiveAt: now - 1 })
+    expect(session.state.value).toEqual(value)
+    session.write({ ...session.state, inactiveAt: now - 1 })
     session.refresh()
-    expect(session.value).not.toEqual(value)
+    expect(session.state.value).not.toEqual(value)
   })
 })
 
@@ -292,20 +298,20 @@ describe('syncCustomAttribute()', () => {
 
     // if custom has never been set, and a "delete" action is triggered, do nothing
     session.syncCustomAttribute('test', null)
-    expect(session?.custom?.test).toEqual(undefined)
+    expect(session?.state?.custom?.test).toEqual(undefined)
 
     session.syncCustomAttribute('test', 1)
-    expect(session?.custom?.test).toEqual(1)
+    expect(session?.state?.custom?.test).toEqual(1)
 
     session.syncCustomAttribute('test', 'string')
-    expect(session?.custom?.test).toEqual('string')
+    expect(session?.state?.custom?.test).toEqual('string')
 
     session.syncCustomAttribute('test', false)
-    expect(session?.custom?.test).toEqual(false)
+    expect(session?.state?.custom?.test).toEqual(false)
 
     // null specifically deletes the object completely
     session.syncCustomAttribute('test', null)
-    expect(session?.custom?.test).toEqual(undefined)
+    expect(session?.state?.custom?.test).toEqual(undefined)
   })
 
   test('Only runs in browser scope', () => {

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

@@ -6,8 +6,9 @@ import { isBrowserScope } from '../util/global-scope'
 export class InteractionTimer extends Timer {
   constructor (opts, ms) {
     super(opts, ms)
-    this.onRefresh = opts.onRefresh
-    this.onPause = opts.onPause
+    this.onPause = typeof opts.onPause === 'function' ? opts.onPause : () => { /* noop */ }
+    this.onRefresh = typeof opts.onRefresh === 'function' ? opts.onRefresh : () => { /* noop */ }
+    this.onResume = typeof opts.onResume === 'function' ? opts.onResume : () => { /* noop */ }
 
     // used by pause/resume
     this.remainingMs = undefined
@@ -42,7 +43,10 @@ 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()
+        else {
+          this.onResume()
+          this.refresh()
+        }
       }, false, false, this.abortController?.signal)
     }
   }
@@ -53,7 +57,7 @@ export class InteractionTimer extends Timer {
   }
 
   pause () {
-    this.onPause?.()
+    this.onPause()
     clearTimeout(this.timer)
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp)
   }
@@ -63,13 +67,6 @@ export class InteractionTimer extends Timer {
     this.timer = this.create(cb, ms)
     this.startTimestamp = Date.now()
     this.remainingMs = undefined
-    this.onRefresh?.()
+    this.onRefresh()
   }
-
-  // NOT CURRENTLY UTILIZED BY ANYTHING
-  // resume () {
-  //   if (!this.remainingMs || !this.isValid()) return
-  //   this.timer = this.create(this.cb, this.remainingMs)
-  //   this.remainingMs = undefined
-  // }
 }

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/url/protocol.test.js

@@ -1,4 +1,3 @@
-import { faker } from '@faker-js/faker'
 import { isFileProtocol } from './protocol'
 
 test('should return true when location url contains file protocol', () => {

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

@@ -12,7 +12,8 @@ const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa]
+  spa: [FEATURE_NAMES.spa],
+  sr: [FEATURE_NAMES.sessionReplay]
 }
 
 export function activateFeatures (flags, agentIdentifier) {
@@ -28,7 +29,6 @@ export function activateFeatures (flags, agentIdentifier) {
     if (activatedFeatures[flag]) {
       return
     }
-
     handle('feat-' + flag, [], undefined, bucketMap[flag], sharedEE)
     activatedFeatures[flag] = true
   })

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/submit-data.js

@@ -7,11 +7,13 @@ export const submitData = {}
 
 /**
  * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} jsonp
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string} args.jsonp - The string name of the jsonp cb method
+ * @returns {XMLHttpRequest}
  * @returns {Element}
  */
-submitData.jsonp = function jsonp (url, jsonp) {
+submitData.jsonp = function jsonp ({ url, jsonp }) {
   try {
     if (isWorkerScope) {
       try {
@@ -19,7 +21,7 @@ submitData.jsonp = function jsonp (url, jsonp) {
       } catch (e) {
         // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
         // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
-        submitData.xhrGet(url + '&jsonp=' + jsonp)
+        submitData.xhrGet({ url: url + '&jsonp=' + jsonp })
         return false
       }
     } else {
@@ -35,18 +37,21 @@ submitData.jsonp = function jsonp (url, jsonp) {
   }
 }
 
-submitData.xhrGet = function xhrGet (url) {
-  return submitData.xhr(url, undefined, false, 'GET')
+submitData.xhrGet = function xhrGet ({ url }) {
+  return submitData.xhr({ url, sync: false, method: 'GET' })
 }
 
 /**
  * Send via XHR
- * @param {string} url
- * @param {string} body
- * @param {boolean} sync
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
+ * @param {boolean=} args.sync - Run XHR as Synchronous
+ * @param {string=} [args.method=POST] - The XHR method to use
+ * @param {{key: string, value: string}[]} [args.headers] - The headers to attach
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr (url, body, sync, method = 'POST') {
+submitData.xhr = function xhr ({ url, body, sync, method = 'POST', headers = [{ key: 'content-type', value: 'text/plain' }] }) {
   var request = new XMLHttpRequest()
 
   request.open(method, url, !sync)
@@ -57,7 +62,10 @@ submitData.xhr = function xhr (url, body, sync, method = 'POST') {
     // do nothing
   }
 
-  request.setRequestHeader('content-type', 'text/plain')
+  headers.forEach(header => {
+    request.setRequestHeader(header.key, header.value)
+  })
+
   request.send(body)
   return request
 }
@@ -71,10 +79,12 @@ submitData.xhr = function xhr (url, body, sync, method = 'POST') {
 
 /**
  * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @returns {Element}
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @returns {HTMLImageElement}
  */
-submitData.img = function img (url) {
+submitData.img = function img ({ url }) {
+  console.log('img url', url)
   var element = new Image()
   element.src = url
   return element
@@ -82,11 +92,12 @@ submitData.img = function img (url) {
 
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
- * @param {string} url
- * @param {string} body
+ * @param {Object} args - The args
+ * @param {string} args.url - The URL to send to
+ * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-submitData.beacon = function (url, body) {
+submitData.beacon = function ({ url, body }) {
   // Navigator has to be bound to ensure it does not error in some browsers
   // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
   const send = window.navigator.sendBeacon.bind(window.navigator)

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 = [...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 = [...arguments]
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis)

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

@@ -71,7 +71,7 @@ export function wrapPromise (sharedEE) {
       WrappedPromise[method] = function (subPromises) { // use our own wrapped version of "Promise.all" and ".race" static fns
         let finalized = false
 
-        Array.from(subPromises || []).forEach(sub => {
+        ;[...subPromises || []].forEach(sub => {
           this.resolve(sub).then(setNrId(method === 'all'), setNrId(false))
         })
 

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

@@ -13,9 +13,9 @@ 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'
+import { AggregateBase } from '../../utils/aggregate-base'
 
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   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