@newrelic/browser-agent 1.236.0 → 1.237.0

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

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

package/src/common/harvest/harvest.js

@@ -16,6 +16,9 @@ import { applyFnToProps } from '../util/traverse'
 import { SharedContext } from '../context/shared-context'
 import { VERSION } from '../constants/env'
 import { isWorkerScope, isIE } from '../constants/runtime'
+import { warn } from '../util/console'
+
+const warnings = {}
 
 /**
  * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
@@ -24,7 +27,6 @@ import { isWorkerScope, isIE } from '../constants/runtime'
  * @typedef {import('./types.js').FeatureHarvestCallback} FeatureHarvestCallback
  * @typedef {import('./types.js').FeatureHarvestCallbackOptions} FeatureHarvestCallbackOptions
  */
-
 export class Harvest extends SharedContext {
   constructor (parent) {
     super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
@@ -107,7 +109,7 @@ export class Harvest extends SharedContext {
     }
 
     const fullUrl = `${url}?${baseParams}${payloadParams}`
-    const gzip = qs.content_encoding === 'gzip'
+    const gzip = !!qs?.attributes?.includes('gzip')
 
     if (!gzip) {
       if (endpoint === 'events') {
@@ -115,6 +117,8 @@ export class Harvest extends SharedContext {
       } else {
         body = stringify(body)
       }
+      /** Warn --once per endpoint-- if the agent tries to send large payloads */
+      if (body.length > 750000 && (warnings[endpoint] = (warnings?.[endpoint] || 0) + 1) === 1) warn(`The Browser Agent is attempting to send a very large payload to /${endpoint}. This is usually tied to large amounts of custom attributes. Please check your configurations.`)
     }
 
     if (!body || body.length === 0 || body === '{}' || body === '[]') {
@@ -156,19 +160,6 @@ export class Harvest extends SharedContext {
       }, eventListenerOpts(false))
     }
 
-    // if beacon request failed, retry with an alternative method -- will not happen for workers
-    if (!result && submitMethod === submitData.beacon) {
-      // browsers that support sendBeacon also support fetch with keepalive - IE will not retry unload calls
-      submitMethod = submitData.fetchKeepAlive
-      try {
-        submitMethod({ url: fullUrl, body, headers })
-      } catch (e) {
-        // Ignore error in final harvest
-      } finally {
-        result = true
-      }
-    }
-
     return result
   }
 
@@ -239,7 +230,7 @@ export class Harvest extends SharedContext {
    */
   cleanPayload (payload = {}) {
     const clean = (input) => {
-      if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) {
+      if ((typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) || typeof input === 'string') {
         return input.length > 0 ? input : null
       }
       return Object.entries(input || {})

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

@@ -3,6 +3,7 @@ import { faker } from '@faker-js/faker'
 import * as encodeModule from '../url/encode'
 import * as submitDataModule from '../util/submit-data'
 import * as configModule from '../config/config'
+import { warn } from '../util/console'
 import { applyFnToProps } from '../util/traverse'
 
 import { Harvest } from './harvest'
@@ -275,7 +276,7 @@ describe('_send', () => {
   })
 
   test('should not alter body when gzip qs is present', () => {
-    spec.payload.qs.content_encoding = 'gzip'
+    spec.payload.qs.attributes += '&content_encoding=gzip'
 
     const result = harvestInstance._send(spec)
 
@@ -288,6 +289,20 @@ describe('_send', () => {
     })
   })
 
+  test('should warn (once) if payload is large', () => {
+    spec.payload.body = 'x'.repeat(1024 * 1024) // ~1mb string
+
+    const result = harvestInstance._send(spec)
+
+    expect(result).toEqual(true)
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('The Browser Agent is attempting to send a very large payload'))
+    expect(warn).toHaveBeenCalledTimes(1)
+
+    const result2 = harvestInstance._send(spec)
+    expect(result2).toEqual(true)
+    expect(warn).toHaveBeenCalledTimes(1)
+  })
+
   test('should set body to events when endpoint is events', () => {
     spec.endpoint = 'events'
     spec.payload.body.e = faker.lorem.sentence()
@@ -440,41 +455,6 @@ describe('_send', () => {
       sent: true
     })
   })
-
-  test('should fallback to fetchKeepAlive when beacon returns false', async () => {
-    jest.mocked(submitDataModule.getSubmitMethod).mockReturnValue(submitDataModule.beacon)
-    jest.mocked(submitDataModule.beacon).mockReturnValue(false)
-    spec.opts.unload = true
-
-    const results = harvestInstance._send(spec)
-    await new Promise(process.nextTick)
-
-    expect(results).toEqual(true)
-    expect(submitDataModule.fetchKeepAlive).toHaveBeenCalledWith({
-      body: JSON.stringify(spec.payload.body),
-      headers: [{ key: 'content-type', value: 'text/plain' }],
-      url: expect.stringContaining(`https://${errorBeacon}/${spec.endpoint}/1/${licenseKey}?`)
-    })
-  })
-
-  test('should not throw an exception if fetchKeepAlive throws error', async () => {
-    jest.mocked(submitDataModule.getSubmitMethod).mockReturnValue(submitDataModule.beacon)
-    jest.mocked(submitDataModule.beacon).mockReturnValue(false)
-    jest.mocked(submitDataModule.fetchKeepAlive).mockImplementation(() => {
-      throw new Error(faker.lorem.sentence())
-    })
-    spec.opts.unload = true
-
-    const results = harvestInstance._send(spec)
-    await new Promise(process.nextTick)
-
-    expect(results).toEqual(true)
-    expect(submitDataModule.fetchKeepAlive).toHaveBeenCalledWith({
-      body: JSON.stringify(spec.payload.body),
-      headers: [{ key: 'content-type', value: 'text/plain' }],
-      url: expect.stringContaining(`https://${errorBeacon}/${spec.endpoint}/1/${licenseKey}?`)
-    })
-  })
 })
 
 describe('obfuscateAndSend', () => {

package/src/common/util/__mocks__/submit-data.js

@@ -2,5 +2,4 @@ export const getSubmitMethod = jest.fn(() => jest.fn())
 export const xhr = jest.fn(() => ({
   addEventListener: jest.fn()
 }))
-export const fetchKeepAlive = jest.fn().mockResolvedValue({})
 export const beacon = jest.fn(() => true)

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

@@ -7,7 +7,7 @@
 import { isBrowserScope, supportsSendBeacon } from '../constants/runtime'
 
 /**
- * @typedef {xhr|fetchKeepAlive|beacon} NetworkMethods
+ * @typedef {xhr|beacon} NetworkMethods
  */
 
 /**
@@ -54,27 +54,6 @@ export function xhr ({ url, body = null, sync, method = 'POST', headers = [{ key
   return request
 }
 
-/**
- * Send via fetch with keepalive true
- * @param {Object} args - The args.
- * @param {string} args.url - The URL to send to.
- * @param {string=} args.body - The Stringified body.
- * @param {string=} [args.method=POST] - The XHR method to use.
- * @param {{key: string, value: string}[]} [args.headers] - The headers to attach.
- * @returns {XMLHttpRequest}
- */
-export function fetchKeepAlive ({ url, body = null, method = 'POST', headers = [{ key: 'content-type', value: 'text/plain' }] }) {
-  return fetch(url, {
-    method,
-    headers: headers.reduce((aggregator, header) => {
-      aggregator.push([header.key, header.value])
-      return aggregator
-    }, []),
-    body,
-    keepalive: true
-  })
-}
-
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
  * @param {Object} args - The args
@@ -90,8 +69,7 @@ export function beacon ({ url, body }) {
     return send(url, body)
   } catch (err) {
     // if sendBeacon still trys to throw an illegal invocation error,
-    // we can catch here and return.  The harvest module will fallback to use
-    // fetchKeepAlive to try to send
+    // we can catch here and return
     return false
   }
 }

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

@@ -141,62 +141,6 @@ describe('xhr', () => {
   })
 })
 
-describe('fetchKeepAlive', () => {
-  beforeEach(() => {
-    global.fetch = jest.fn().mockReturnValue(Promise.resolve())
-  })
-
-  afterEach(() => {
-    delete global.fetch
-  })
-
-  test('should make a fetch with default values', () => {
-    submitData.fetchKeepAlive({ url })
-
-    expect(global.fetch).toHaveBeenCalledWith(url, {
-      method: 'POST',
-      body: null,
-      keepalive: true,
-      headers: [['content-type', 'text/plain']]
-    })
-  })
-
-  test('should send the body when provided', () => {
-    const body = faker.lorem.paragraph()
-    submitData.fetchKeepAlive({ url, body })
-
-    expect(global.fetch).toHaveBeenCalledWith(url, {
-      method: 'POST',
-      body,
-      keepalive: true,
-      headers: [['content-type', 'text/plain']]
-    })
-  })
-
-  test('should use the provided method', () => {
-    submitData.fetchKeepAlive({ url, method: 'HEAD' })
-
-    expect(global.fetch).toHaveBeenCalledWith(url, {
-      method: 'HEAD',
-      body: null,
-      keepalive: true,
-      headers: [['content-type', 'text/plain']]
-    })
-  })
-
-  test('should use the provided headers', () => {
-    const headers = [{ key: faker.lorem.word(), value: faker.datatype.uuid() }]
-    submitData.fetchKeepAlive({ url, headers })
-
-    expect(global.fetch).toHaveBeenCalledWith(url, {
-      method: 'POST',
-      body: null,
-      keepalive: true,
-      headers: [[headers[0].key, headers[0].value]]
-    })
-  })
-})
-
 describe('beacon', () => {
   afterEach(() => {
     delete window.navigator.sendBeacon

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

@@ -98,13 +98,18 @@ export function wrapJsonP (sharedEE) {
     return matches ? matches[1] : null
   }
 
+  /**
+   * Traverse a nested object using a '.'-delimited string wherein each substring piece maps to each subsequent object property layer.
+   * @param {string} longKey
+   * @param {object} obj
+   * @returns The final nested object referred to by initial longKey.
+   */
   function discoverValue (longKey, obj) {
-    var matches = longKey.match(VALUE_REGEX)
-    var key = matches[1]
-    var remaining = matches[3]
-    if (!remaining) {
-      return obj[key]
-    }
+    if (!longKey) return obj // end of object recursion depth when no more key levels
+    const matches = longKey.match(VALUE_REGEX)
+    // if 'longKey' was not undefined, that is it at least had 1 level left, then the regexp would've at least matched 1st group
+    const key = matches[1]
+    const remaining = matches[3]
     return discoverValue(remaining, obj[key])
   }
 

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

@@ -6,7 +6,7 @@ import { registerHandler as register } from '../../../common/event-emitter/regis
 import { stringify } from '../../../common/util/stringify'
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer'
 import { handle } from '../../../common/event-emitter/handle'
-import { getConfigurationValue, getInfo } from '../../../common/config/config'
+import { getConfiguration, getInfo, getRuntime } from '../../../common/config/config'
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list'
 import { FEATURE_NAME } from '../constants'
@@ -19,15 +19,25 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)
+    const agentInit = getConfiguration(agentIdentifier)
+    const allAjaxIsEnabled = agentInit.ajax.enabled !== false
+
+    register('xhr', storeXhr, this.featureName, this.ee)
+    if (!allAjaxIsEnabled) {
+      drain(this.agentIdentifier, this.featureName)
+      return // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
+    }
+
+    const denyList = getRuntime(agentIdentifier).denyList
+    setDenyList(denyList)
+
     let ajaxEvents = []
     let spaAjaxEvents = {}
     let sentAjaxEvents = []
-    let scheduler
-
     const ee = this.ee
 
-    const harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'ajax.harvestTimeSeconds') || 10
-    const MAX_PAYLOAD_SIZE = getConfigurationValue(agentIdentifier, 'ajax.maxPayloadSize') || 1000000
+    const harvestTimeSeconds = agentInit.ajax.harvestTimeSeconds || 10
+    const MAX_PAYLOAD_SIZE = agentInit.ajax.maxPayloadSize || 1000000
 
     // Exposes these methods to browser test files -- future TO DO: can be removed once these fns are extracted from the constructor into class func
     this.storeXhr = storeXhr
@@ -39,9 +49,8 @@ export class Aggregate extends AggregateBase {
       // remove from the spaAjaxEvents buffer, and let spa harvest it
       delete spaAjaxEvents[interaction.id]
     })
-
     ee.on('interactionDiscarded', (interaction) => {
-      if (!spaAjaxEvents[interaction.id] || !allAjaxIsEnabled()) return
+      if (!spaAjaxEvents[interaction.id]) return
 
       spaAjaxEvents[interaction.id].forEach(function (item) {
         // move it from the spaAjaxEvents buffer to the ajaxEvents buffer for harvesting here
@@ -50,18 +59,15 @@ export class Aggregate extends AggregateBase {
       delete spaAjaxEvents[interaction.id]
     })
 
-    if (allAjaxIsEnabled()) setDenyList(getConfigurationValue(agentIdentifier, 'ajax.deny_list'))
-
-    register('xhr', storeXhr, this.featureName, this.ee)
+    const scheduler = new HarvestScheduler('events', {
+      onFinished: onEventsHarvestFinished,
+      getPayload: prepareHarvest
+    }, this)
 
-    if (allAjaxIsEnabled()) {
-      scheduler = new HarvestScheduler('events', {
-        onFinished: onEventsHarvestFinished,
-        getPayload: prepareHarvest
-      }, this)
+    ee.on(`drain-${this.featureName}`, () => { scheduler.startTimer(harvestTimeSeconds) })
 
-      ee.on(`drain-${this.featureName}`, () => { scheduler.startTimer(harvestTimeSeconds) })
-    }
+    drain(this.agentIdentifier, this.featureName)
+    return
 
     function storeXhr (params, metrics, startTime, endTime, type) {
       metrics.time = startTime
@@ -79,9 +85,7 @@ export class Aggregate extends AggregateBase {
       // store as metric
       aggregator.store('xhr', hash, params, metrics)
 
-      if (!allAjaxIsEnabled()) {
-        return
-      }
+      if (!allAjaxIsEnabled) return
 
       if (!shouldCollectEvent(params)) {
         if (params.hostname === getInfo(agentIdentifier).errorBeacon) {
@@ -172,7 +176,7 @@ export class Aggregate extends AggregateBase {
     }
 
     function onEventsHarvestFinished (result) {
-      if (result.retry && sentAjaxEvents.length > 0 && allAjaxIsEnabled()) {
+      if (result.retry && sentAjaxEvents.length > 0) {
         ajaxEvents.unshift(...sentAjaxEvents)
         sentAjaxEvents = []
       }
@@ -234,15 +238,5 @@ export class Aggregate extends AggregateBase {
         return this.payload.length * 2 > maxPayloadSize
       }
     }
-
-    function allAjaxIsEnabled () {
-      var enabled = getConfigurationValue(agentIdentifier, 'ajax.enabled')
-      if (enabled === false) {
-        return false
-      }
-      return true
-    }
-
-    drain(this.agentIdentifier, this.featureName)
   }
 }

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

@@ -233,7 +233,7 @@ function computeStackTraceBySourceAndLine (ex) {
       mode: 'sourceline',
       name: className,
       message: ex.message,
-      stackString: getClassName(ex) + ': ' + ex.message + '\n    in evaluated code',
+      stackString: className + ': ' + ex.message + '\n    in evaluated code',
       frames: [{
         func: 'evaluated code'
       }]

package/src/features/jserrors/constants.js

@@ -1,4 +1,3 @@
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
 export const FEATURE_NAME = FEATURE_NAMES.jserrors
-export const NR_ERR_PROP = 'nr@seenError'