@newrelic/browser-agent 1.237.1 → 1.239.0

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

@@ -1,31 +1,104 @@
-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()
-  })
+jest.enableAutomock()
+jest.unmock('./deny-list')
+
+let denyListModule
+
+beforeEach(async () => {
+  denyListModule = await import('./deny-list')
+})
+
+afterEach(() => {
+  jest.resetModules()
+})
+
+test('domain-only blocks all subdomains and all paths', () => {
+  denyListModule.setDenyList(['foo.com'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a/b' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/c/d' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'oo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeTruthy()
+})
+
+test('subdomain blocks further subdomains, but not parent domain', () => {
+  denyListModule.setDenyList(['bar.foo.com'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.foo.com', pathname: '/a' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.foo.com', pathname: '/a/b' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.bar.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.bar.foo.com', pathname: '/a' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.bar.foo.com', pathname: '/a/b' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a/b' })).toBeTruthy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'oo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeTruthy()
+})
+
+test('* blocks all domains', () => {
+  denyListModule.setDenyList(['*'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.foo.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.bar.com', pathname: '/' })).toBeFalsy()
+})
+
+test('respects path', () => {
+  denyListModule.setDenyList(['bam.nr-data.net/somepath'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '/somepath' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'https', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '/someotherpath' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '/some/otherpath' })).toBeTruthy()
+})
+
+test('ignores port', () => {
+  denyListModule.setDenyList(['bam.nr-data.net:1234'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '', port: '4321' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'http', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '' })).toBeTruthy()
+})
+
+test('ignores protocol', () => {
+  denyListModule.setDenyList(['http://bam.nr-data.net'])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', pathname: '', protocol: 'https' })).toBeFalsy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.net', port: '7890', protocol: 'https', host: 'bam.nr-data.net:7890', pathname: '/somepath' })).toBeFalsy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bam.nr-data.com', pathname: '', protocol: 'http' })).toBeTruthy()
+})
+
+test.each([
+  null,
+  undefined,
+  '!@$%^*',
+  'https://example.com/http://foo.bar/'
+])('ignores invalid deny list value %s', (denyListValue) => {
+  denyListModule.setDenyList([denyListValue])
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'foo.com', pathname: '/a/b' })).toBeTruthy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'www.foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'a.b.foo.com', pathname: '/c/d' })).toBeTruthy()
+
+  expect(denyListModule.shouldCollectEvent({ hostname: 'oo.com', pathname: '/' })).toBeTruthy()
+  expect(denyListModule.shouldCollectEvent({ hostname: 'bar.com', pathname: '/' })).toBeTruthy()
 })

package/src/common/drain/drain.js

@@ -44,7 +44,6 @@ function curateRegistry (agentIdentifier) {
  */
 export function drain (agentIdentifier = '', featureName = 'feature') {
   curateRegistry(agentIdentifier)
-
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
   // This could happen in tests, or loaders that directly import the aggregator. In these cases it is safe to
   // drain the feature group immediately rather than waiting to drain all at once.
@@ -59,6 +58,7 @@ export function drain (agentIdentifier = '', featureName = 'feature') {
   if (items.every(([key, values]) => values.staged)) {
     items.sort((a, b) => a[1].priority - b[1].priority)
     items.forEach(([group]) => {
+      registry[agentIdentifier].delete(group)
       drainGroup(group)
     })
   }

package/src/common/drain/drain.test.js

@@ -0,0 +1,74 @@
+let registerDrain, drain, ee
+beforeEach(async () => {
+  jest.resetModules()
+  ;({ registerDrain, drain } = await import('./drain'))
+  ;({ ee } = await import('../event-emitter/contextual-ee'))
+})
+
+test('can register a feat and drain it', () => {
+  registerDrain('abcd', 'page_view_event')
+
+  let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+  drain('abcd', 'page_view_event')
+  expect(emitSpy).toHaveBeenCalledWith('drain-page_view_event', expect.anything())
+})
+
+test('other unregistered drains do not affect feat reg & drain', () => {
+  registerDrain('abcd', 'page_view_event')
+
+  let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+  drain('abcd', 'timon')
+  expect(emitSpy).toHaveBeenCalledWith('drain-timon', expect.anything())
+  expect(emitSpy).not.toHaveBeenCalledWith('drain-page_view_event', expect.anything())
+
+  drain('abcd', 'page_view_event')
+  expect(emitSpy).toHaveBeenCalledWith('drain-page_view_event', expect.anything())
+})
+
+describe('drain', () => {
+  test('does not execute until all registered groups calls it and in order', () => {
+    registerDrain('abcd', 'page_view_timing')
+    registerDrain('abcd', 'page_view_event')
+
+    let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+    drain('abcd', 'page_view_event')
+    expect(emitSpy).not.toHaveBeenCalled()
+
+    drain('abcd', 'page_view_timing')
+    // The priority order of features is also checked here, even though the latter was registered first.
+    expect(emitSpy).toHaveBeenNthCalledWith(1, 'drain-page_view_event', expect.anything())
+    expect(emitSpy).toHaveBeenNthCalledWith(2, 'drain-page_view_timing', expect.anything())
+  })
+
+  test('does not require registration for non-feat groups', () => {
+    let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+    drain('abcd', 'pumbaa')
+    expect(emitSpy).toHaveBeenCalledWith('drain-pumbaa', expect.anything())
+  })
+
+  test('defaults to "feature" group when not provided one', () => {
+    let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+    drain('abcd')
+    expect(emitSpy).toHaveBeenCalledWith('drain-feature', expect.anything())
+  })
+
+  test('works on the global ee when agent id not provided', () => {
+    let emitSpy = jest.spyOn(ee, 'emit')
+    drain()
+    expect(emitSpy).toHaveBeenCalledWith('drain-feature', expect.anything())
+  })
+})
+
+test('non-feat groups can register and drain too alongside features', () => {
+  registerDrain('abcd', 'page_view_event')
+  registerDrain('abcd', 'simba')
+
+  console.log(JSON.stringify(ee.get('abcd')))
+  let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+  drain('abcd', 'simba')
+  expect(emitSpy).not.toHaveBeenCalled()
+
+  drain('abcd', 'page_view_event')
+  expect(emitSpy).toHaveBeenNthCalledWith(1, 'drain-simba', expect.anything()) // non-feat have prio of 0
+  expect(emitSpy).toHaveBeenNthCalledWith(2, 'drain-page_view_event', expect.anything())
+})

package/src/common/event-emitter/{contextual-ee.test.js → contextual-ee.component-test.js}

@@ -24,19 +24,18 @@ afterEach(() => {
 })
 
 describe('global event-emitter', () => {
-  test('it returns the event-emitter defined on window.NREUM', async () => {
-    const mockEE = {}
-    mockNREUM.ee = mockEE
-
+  test('it sets the global event-emitter on window.NREUM when it does not already exist', async () => {
     const { ee } = await import('./contextual-ee')
 
-    expect(ee).toEqual(mockEE)
+    expect(ee).toEqual(mockNREUM.ee)
   })
 
-  test('it sets the global event-emitter on window.NREUM', async () => {
+  test('it does not set the global event-emitter on window.NREUM when it already exists', async () => {
+    mockNREUM.ee = {}
+
     const { ee } = await import('./contextual-ee')
 
-    expect(ee).toEqual(mockNREUM.ee)
+    expect(ee).not.toEqual(mockNREUM.ee)
   })
 })
 
@@ -79,7 +78,9 @@ describe('event-emitter context', () => {
 
     const result = ee.context()
 
-    expect(result).toEqual({})
+    expect(result).toEqual(expect.objectContaining({
+      contextId: expect.stringContaining('nr@context:')
+    }))
   })
 
   test('it returns the same context', async () => {
@@ -87,7 +88,7 @@ describe('event-emitter context', () => {
 
     const result = ee.context()
 
-    expect(result).toEqual(ee.context(result))
+    expect(result).toBe(ee.context(result))
   })
 
   test('it adds the context to the provided object', async () => {
@@ -95,8 +96,9 @@ describe('event-emitter context', () => {
 
     const obj = {}
     const result = ee.context(obj)
+    const ctxKey = Object.getOwnPropertyNames(obj).find(k => k.startsWith('nr@context'))
 
-    expect(result).toEqual(obj['nr@context'])
+    expect(result).toBe(obj[ctxKey])
   })
 })
 
@@ -281,30 +283,11 @@ describe('event-emitter emit', () => {
         scopeEE,
         eventType,
         eventArgs,
-        {}
+        expect.objectContaining({
+          contextId: expect.stringContaining('nr@context:')
+        })
       ])
     ]))
     expect(ee.backlog.feature).toEqual(scopeEE.backlog.feature)
   })
 })
-
-describe('getOrSetContext', () => {
-  test('it returns a new context', async () => {
-    const { getOrSetContext } = await import('./contextual-ee')
-
-    const obj = {}
-    const result = getOrSetContext(obj)
-
-    expect(result).toEqual({})
-    expect(result).toEqual(obj['nr@context'])
-  })
-
-  test('it returns the same context', async () => {
-    const { getOrSetContext } = await import('./contextual-ee')
-
-    const obj = {}
-    const result = getOrSetContext(obj)
-
-    expect(getOrSetContext(obj)).toEqual(result)
-  })
-})

package/src/common/event-emitter/contextual-ee.js

@@ -5,25 +5,22 @@
 
 import { gosNREUM } from '../window/nreum'
 import { getOrSet } from '../util/get-or-set'
-import { mapOwn } from '../util/map-own'
 import { getRuntime } from '../config/config'
+import { EventContext } from './event-context'
+import { bundleId } from '../ids/bundle-id'
 
-var ctxId = 'nr@context'
-
+// create a unique id to store event context data for the current agent bundle
+const contextId = `nr@context:${bundleId}`
 // create global emitter instance that can be shared among bundles
-let nr = gosNREUM()
-var globalInstance
+const globalInstance = ee(undefined, 'globalEE')
 
-if (nr.ee) {
-  globalInstance = nr.ee
-} else {
-  globalInstance = ee(undefined, 'globalEE')
+// Only override the exposed event emitter if one has not already been exposed
+const nr = gosNREUM()
+if (!nr.ee) {
   nr.ee = globalInstance
 }
 
-export { globalInstance as ee }
-
-function EventContext () { }
+export { globalInstance as ee, contextId }
 
 function ee (old, debugId) {
   var handlers = {}
@@ -44,16 +41,16 @@ function ee (old, debugId) {
 
   var emitter = {
     on: addEventListener,
-    addEventListener: addEventListener,
-    removeEventListener: removeEventListener,
-    emit: emit,
+    addEventListener,
+    removeEventListener,
+    emit,
     get: getOrCreate,
-    listeners: listeners,
-    context: context,
+    listeners,
+    context,
     buffer: bufferEventsByGroup,
     abort,
     aborted: false,
-    isBuffering: isBuffering,
+    isBuffering,
     debugId,
     backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
 
@@ -65,9 +62,9 @@ function ee (old, debugId) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ctxId, getNewContext)
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId))
     } else {
-      return getNewContext()
+      return new EventContext(contextId)
     }
   }
 
@@ -119,17 +116,18 @@ function ee (old, debugId) {
   }
 
   function bufferEventsByGroup (types, group) {
-    var eventBuffer = getBuffer()
+    const eventBuffer = getBuffer()
+    group = group || 'feature'
 
     // do not buffer events if agent has been aborted
     if (emitter.aborted) return
-    mapOwn(types, function (i, type) {
-      group = group || 'feature'
-      bufferGroupMap[type] = group
-      if (!(group in eventBuffer)) {
-        eventBuffer[group] = []
-      }
-    })
+    Object.entries(types || {})
+      .forEach(([_, type]) => {
+        bufferGroupMap[type] = group
+        if (!(group in eventBuffer)) {
+          eventBuffer[group] = []
+        }
+      })
   }
 
   function isBuffering (type) {
@@ -144,15 +142,6 @@ function ee (old, debugId) {
   }
 }
 
-// get context object from store object, or create if does not exist
-export function getOrSetContext (obj) {
-  return getOrSet(obj, ctxId, getNewContext)
-}
-
-function getNewContext () {
-  return new EventContext()
-}
-
 function abort () {
   globalInstance.aborted = true
   globalInstance.backlog = {}

package/src/common/event-emitter/event-context.js

@@ -0,0 +1,5 @@
+export class EventContext {
+  constructor (contextId) {
+    this.contextId = contextId
+  }
+}

package/src/common/harvest/harvest-scheduler.js

@@ -7,7 +7,6 @@ import * as submitData from '../util/submit-data'
 import { SharedContext } from '../context/shared-context'
 import { Harvest } from './harvest'
 import { subscribeToEOL } from '../unload/eol'
-import { getConfigurationValue } from '../config/config'
 import { SESSION_EVENTS } from '../session/session-entity'
 
 /**
@@ -36,7 +35,7 @@ export class HarvestScheduler extends SharedContext {
     this.harvest = new Harvest(this.sharedContext)
 
     // unload if EOL mechanism fires
-    subscribeToEOL(this.unload.bind(this), getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')) // TO DO: remove feature flag after rls stable
+    subscribeToEOL(this.unload.bind(this))
 
     /* Flush all buffered data if session resets and give up retries. This should be synchronous to ensure that the correct `session` value is sent.
       Since session-reset generates a new session ID and the ID is grabbed at send-time, any delays or retries would cause the payload to be sent under
@@ -103,7 +102,7 @@ export class HarvestScheduler extends SharedContext {
       if (!submitMethod) return false
 
       const retry = !opts?.unload && submitMethod === submitData.xhr
-      payload = this.opts.getPayload({ retry: retry })
+      payload = this.opts.getPayload({ retry })
 
       if (!payload) {
         if (this.started) {
@@ -143,8 +142,6 @@ export class HarvestScheduler extends SharedContext {
     if (this.started) {
       this.scheduleHarvest()
     }
-
-    return
   }
 
   onHarvestFinished (opts, result) {

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

@@ -2,7 +2,6 @@ import { faker } from '@faker-js/faker'
 
 import * as submitData from '../util/submit-data'
 import { subscribeToEOL } from '../unload/eol'
-import { getConfigurationValue } from '../config/config'
 import { Harvest } from './harvest'
 
 import { HarvestScheduler } from './harvest-scheduler'
@@ -31,13 +30,10 @@ describe('unload', () => {
     jest.spyOn(harvestSchedulerInstance, 'runHarvest').mockImplementation(jest.fn())
   })
 
-  test('should subscribe to eol with allow_bfcache setting', () => {
-    const mockedBFCacheSetting = faker.datatype.uuid()
-    jest.mocked(getConfigurationValue).mockReturnValue(mockedBFCacheSetting)
-
+  test('should subscribe to eol', () => {
     new HarvestScheduler()
 
-    expect(subscribeToEOL).toHaveBeenCalledWith(expect.any(Function), mockedBFCacheSetting)
+    expect(subscribeToEOL).toHaveBeenCalledWith(expect.any(Function))
   })
 
   test('should run onUnload callback', () => {

package/src/common/harvest/harvest.js

@@ -47,7 +47,8 @@ export class Harvest extends SharedContext {
   sendX (spec = {}) {
     const submitMethod = submitData.getSubmitMethod({ isFinalHarvest: spec.opts?.unload })
     const options = {
-      retry: !spec.opts?.unload && submitMethod === submitData.xhr
+      retry: !spec.opts?.unload && submitMethod === submitData.xhr,
+      isFinalHarvest: spec.opts?.unload === true
     }
     const payload = this.createPayload(spec.endpoint, options)
     const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this)
@@ -95,7 +96,8 @@ export class Harvest extends SharedContext {
       return false
     }
 
-    let url = `${this.getScheme()}://${info.errorBeacon}${endpoint !== 'rum' ? `/${endpoint}` : ''}/1/${info.licenseKey}`
+    const endpointURLPart = endpoint !== 'rum' ? `/${endpoint}` : ''
+    let url = `${this.getScheme()}://${info.errorBeacon}${endpointURLPart}/1/${info.licenseKey}`
     if (customUrl) url = customUrl
     if (raw) url = `${this.getScheme()}://${info.errorBeacon}/${endpoint}`
 
@@ -126,11 +128,6 @@ export class Harvest extends SharedContext {
       body = ''
     }
 
-    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0
-    // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.length || 0
-
     const headers = []
 
     headers.push({ key: 'content-type', value: 'text/plain' })

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

@@ -53,7 +53,7 @@ describe('sendX', () => {
 
     harvestInstance.sendX(spec)
 
-    expect(harvestInstance.createPayload).toHaveBeenCalledWith(spec.endpoint, { retry: true })
+    expect(harvestInstance.createPayload).toHaveBeenCalledWith(spec.endpoint, { retry: true, isFinalHarvest: false })
   })
 
   test('should not use obfuscateAndSend', async () => {
@@ -157,8 +157,6 @@ describe('_send', () => {
       licenseKey
     })
     jest.mocked(configModule.getRuntime).mockReturnValue({
-      bytesSent: {},
-      queryBytesSent: {},
       maxBytes: Infinity
     })
 

package/src/common/ids/__mocks__/bundle-id.js

@@ -0,0 +1,2 @@
+import { faker } from '@faker-js/faker'
+export const bundleId = faker.datatype.uuid()

package/src/common/ids/__mocks__/unique-id.js

@@ -0,0 +1,17 @@
+import { faker } from '@faker-js/faker'
+
+export function generateUuid () {
+  return faker.datatype.uuid()
+}
+
+export function generateRandomHexString (length) {
+  return faker.datatype.hexadecimal({ length, prefix: '' })
+}
+
+export function generateSpanId () {
+  return generateRandomHexString(16)
+}
+
+export function generateTraceId () {
+  return generateRandomHexString(32)
+}

package/src/common/ids/bundle-id.js

@@ -0,0 +1,13 @@
+/**
+ * @file Contains a unique identifier for the running agent bundle
+ * when loaded.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+
+import { generateUuid } from './unique-id'
+
+/**
+ * Provides a unique id for the current agent bundle
+ */
+export const bundleId = generateUuid()

package/src/common/ids/id.test.js

@@ -67,25 +67,25 @@ test('id is zero on global scope', async () => {
 })
 
 test('id on prototype is correctly inherited', () => {
-  const fn = jest.fn()
+  const Ctor = jest.fn()
   const a = {}
 
   idFn(a)
-  fn.prototype = a
+  Ctor.prototype = a
 
-  const b = new fn()
+  const b = new Ctor()
 
   expect(b['nr@id']).toEqual(a['nr@id'])
 })
 
 test('id on prototype is different from instance', () => {
-  const fn = jest.fn()
+  const Ctor = jest.fn()
   const a = {}
 
   idFn(a)
-  fn.prototype = a
+  Ctor.prototype = a
 
-  const b = new fn()
+  const b = new Ctor()
   const result = idFn(b)
 
   expect(b['nr@id']).toEqual(result)

package/src/common/serialize/bel-serializer.js

@@ -32,7 +32,7 @@ export function getAddStringContext (agentIdentifier) {
 
   function addString (str) {
     if (typeof str === 'undefined' || str === '') return ''
-    var obfuscator = new Obfuscator({ agentIdentifier: agentIdentifier })
+    var obfuscator = new Obfuscator({ agentIdentifier })
     str = String(str)
     if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str)
     if (hasOwnProp.call(stringTable, str)) {

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

@@ -13,6 +13,7 @@ class LocalMemory {
     try {
       return this.state[key]
     } catch (err) {
+      // Error is ignored
       return ''
     }
   }
@@ -22,7 +23,7 @@ class LocalMemory {
       if (value === undefined || value === null) return this.remove(key)
       this.state[key] = value
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 
@@ -30,7 +31,7 @@ class LocalMemory {
     try {
       delete this.state[key]
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 }