@newrelic/browser-agent 1.233.1 → 1.235.0

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

@@ -1,34 +1,45 @@
+import { faker } from '@faker-js/faker'
+import * as globalScopeModule from '../util/global-scope'
+import * as cleanUrlModule from './clean-url'
+import { canonicalizeUrl } from './canonicalize-url'
+
+jest.mock('../util/global-scope')
+jest.mock('./clean-url')
+
+beforeEach(() => {
+  jest.spyOn(cleanUrlModule, 'cleanURL').mockImplementation(input => input)
+  jest.replaceProperty(globalScopeModule, 'initialLocation', faker.internet.url())
+})
+
 afterEach(() => {
-  jest.resetModules()
+  jest.resetAllMocks()
 })
 
 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('uses cleanURL to clean the input and initial location URLs', () => {
+  const url = faker.internet.url()
+  canonicalizeUrl(url)
+
+  expect(cleanUrlModule.cleanURL).toHaveBeenCalledWith(globalScopeModule.initialLocation)
+  expect(cleanUrlModule.cleanURL).toHaveBeenCalledWith(url)
+  expect(cleanUrlModule.cleanURL).toHaveBeenCalledTimes(2)
 })
 
-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('returns <inline> when input and initial page urls are the same', async () => {
+  expect(canonicalizeUrl(globalScopeModule.initialLocation)).toEqual('<inline>')
+})
+
+test('returns input url when it does not match initial page url', async () => {
+  const url = faker.internet.url()
+
+  expect(canonicalizeUrl(url)).toEqual(url)
 })
 
 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>')
+  const url = globalScopeModule.initialLocation + '/path/to/script.js'
+
+  expect(canonicalizeUrl(url)).not.toEqual('<inline>')
 })

package/src/common/url/encode.js

@@ -48,11 +48,11 @@ export function obj (payload, maxBytes) {
     var next
     var i
 
-    if (typeof dataArray === 'string') {
+    if (typeof dataArray === 'string' || (!Array.isArray(dataArray) && dataArray !== null && dataArray !== undefined && dataArray.toString().length)) {
       next = '&' + feature + '=' + qs(dataArray)
       total += next.length
       result += next
-    } else if (dataArray.length) {
+    } else if (Array.isArray(dataArray) && dataArray.length) {
       total += 9
       for (i = 0; i < dataArray.length; i++) {
         next = qs(stringify(dataArray[i]))

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

@@ -0,0 +1,34 @@
+import { warn } from './console'
+
+beforeEach(() => {
+  console.warn = jest.fn()
+})
+
+afterEach(() => {
+  jest.restoreAllMocks()
+})
+
+describe('warn', () => {
+  test('should not call console.warn if it is not a function', () => {
+    const spy = jest.spyOn(console, 'warn')
+    console.warn = undefined
+    warn('test message')
+    expect(spy).not.toHaveBeenCalled()
+  })
+
+  test('should call console.warn with a prefixed message', () => {
+    warn('test message')
+    expect(console.warn).toHaveBeenCalledWith('New Relic: test message')
+  })
+
+  test('should call console.warn with secondary argument if provided', () => {
+    const secondary = 'secondary value'
+    warn('test message', secondary)
+    expect(console.warn).toHaveBeenCalledWith(secondary)
+  })
+
+  test('should not call console.warn with secondary argument if not provided', () => {
+    warn('test message')
+    expect(console.warn).toHaveBeenCalledTimes(1)
+  })
+})

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

@@ -1,24 +1,29 @@
+import { faker } from '@faker-js/faker'
+import * as stringifyModule from './stringify'
 import { dataSize } from './data-size'
 
+jest.mock('./stringify')
+
 describe('dataSize', () => {
   test('returns length of string', () => {
-    const str = 'Hello, world!'
+    const str = faker.lorem.sentence()
     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(NaN)).toBeUndefined()
+    expect(dataSize(12345)).toBeUndefined()
     expect(dataSize('')).toBeUndefined()
   })
 
   test('returns byte length of ArrayBuffer object', () => {
-    const buffer = new ArrayBuffer(8)
-    expect(dataSize(buffer)).toBe(8)
+    const buffer = new ArrayBuffer(faker.datatype.number({ min: 10, max: 100 }))
+    expect(dataSize(buffer)).toBe(buffer.byteLength)
   })
 
   test('returns size of Blob object', () => {
-    const blob = new Blob(['Hello, world!'], { type: 'text/plain' })
+    const blob = new Blob([faker.lorem.sentence()], { type: 'text/plain' })
     expect(dataSize(blob)).toBe(blob.size)
   })
 
@@ -27,24 +32,26 @@ describe('dataSize', () => {
     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]
-      }
+  test('uses stringify to get the length of an object', () => {
+    const input = {
+      [faker.datatype.uuid()]: faker.lorem.sentence()
     }
-    const expectedSize = JSON.stringify(obj).length
-    expect(dataSize(obj)).toBe(expectedSize)
+    const expectedSize = faker.datatype.number({ min: 1000, max: 10000 })
+
+    jest.spyOn(stringifyModule, 'stringify').mockReturnValue({ length: expectedSize })
+
+    expect(dataSize(input)).toBe(expectedSize)
   })
 
-  test('returns undefined for object with toJSON method that throws an error', () => {
-    const obj = {
-      toJSON: () => {
-        throw new Error('Error in toJSON')
-      }
+  test('should not throw an exception if stringify throws an exception', () => {
+    const input = {
+      [faker.datatype.uuid()]: faker.lorem.sentence()
     }
-    expect(dataSize(obj)).toBeUndefined()
+    const expectedSize = faker.datatype.number({ min: 1000, max: 10000 })
+
+    jest.spyOn(stringifyModule, 'stringify').mockImplementation(() => { throw new Error(faker.lorem.sentence()) })
+
+    expect(() => dataSize(input)).not.toThrow()
+    expect(dataSize(input)).toBeUndefined()
   })
 })

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

@@ -2,7 +2,6 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { mapOwn } from './map-own'
 import { ee } from '../event-emitter/contextual-ee'
 import { handle } from '../event-emitter/handle'
 import { drain } from '../drain/drain'
@@ -13,24 +12,37 @@ const bucketMap = {
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
   spa: [FEATURE_NAMES.spa],
-  sr: [FEATURE_NAMES.sessionReplay]
+  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
 }
 
+/** 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) {
-  var sharedEE = ee.get(agentIdentifier)
+  const sharedEE = ee.get(agentIdentifier)
   if (!(flags && typeof flags === 'object')) return
-  mapOwn(flags, function (flag, val) {
-    if (!val) {
-      return (bucketMap[flag] || []).forEach(feat => {
-        handle('block-' + flag, [], undefined, feat, sharedEE)
+
+  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 (activatedFeatures[flag]) {
-      return
+  // 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.
+  Object.keys(bucketMap).forEach(flag => {
+    if (activatedFeatures[flag] === undefined) {
+      bucketMap[flag]?.forEach(feat => handle('rumresp-' + flag, [false], undefined, feat, sharedEE))
+      activatedFeatures[flag] = false
     }
-    handle('feat-' + flag, [], undefined, bucketMap[flag], sharedEE)
-    activatedFeatures[flag] = true
   })
   drain(agentIdentifier, FEATURE_NAMES.pageViewEvent)
 }

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

@@ -0,0 +1,98 @@
+import { faker } from '@faker-js/faker'
+import * as eventEmitterModule from '../event-emitter/contextual-ee'
+import * as handleModule from '../event-emitter/handle'
+import * as drainModule from '../drain/drain'
+import { activateFeatures, activatedFeatures } from './feature-flags'
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+jest.mock('../event-emitter/handle')
+jest.mock('../drain/drain')
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  ee: {
+    get: jest.fn(() => ({
+      foo: `bar_${Math.random()}`
+    }))
+  }
+}))
+
+let agentIdentifier
+
+beforeEach(() => {
+  agentIdentifier = faker.datatype.uuid()
+})
+
+afterEach(() => {
+  Object.keys(activatedFeatures)
+    .forEach(key => delete activatedFeatures[key])
+})
+
+test.each([
+  null,
+  undefined
+])('should not do anything when flags is %s', (input) => {
+  activateFeatures(input, agentIdentifier)
+
+  expect(handleModule.handle).not.toHaveBeenCalled()
+  expect(drainModule.drain).not.toHaveBeenCalled()
+  expect(activatedFeatures).toEqual({})
+})
+
+const bucketMap = {
+  stn: [FEATURE_NAMES.sessionTrace],
+  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
+  ins: [FEATURE_NAMES.pageAction],
+  spa: [FEATURE_NAMES.spa],
+  sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
+}
+
+test('emits the right events when feature flag = 1', () => {
+  const flags = {}
+  Object.keys(bucketMap).forEach(flag => flags[flag] = 1)
+  activateFeatures(flags, agentIdentifier)
+
+  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
+
+  // each flag gets emitted to each of its mapped features, and a feat- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
+  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)
+  expect(activatedFeatures).toEqual(flags)
+})
+
+test('emits the right events when feature flag = 0', () => {
+  const flags = {}
+  Object.keys(bucketMap).forEach(flag => flags[flag] = 0)
+  activateFeatures(flags, agentIdentifier)
+
+  const sharedEE = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
+
+  // each flag gets emitted to each of its mapped features, and a block- AND a rumresp- for every emit, so (1+2+1+1+2)*2 = 14
+  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)
+  expect(activatedFeatures).toEqual(flags)
+})
+
+test('only the first activate of the same feature is respected', () => {
+  const flags = { stn: 1 }
+  activateFeatures(flags, agentIdentifier)
+  flags.stn = 0
+  activateFeatures(flags, agentIdentifier)
+
+  const sharedEE1 = jest.mocked(eventEmitterModule.ee.get).mock.results[0].value
+  const sharedEE2 = jest.mocked(eventEmitterModule.ee.get).mock.results[1].value
+
+  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/get-or-set.js

@@ -5,7 +5,14 @@
 
 var has = Object.prototype.hasOwnProperty
 
-// Always returns the current value of obj[prop], even if it has to set it first
+/**
+ * Always returns the current value of obj[prop], even if it has to set it first. Sets properties as non-enumerable if possible.
+ *
+ * @param {Object} obj - The object to get or set the property on.
+ * @param {string} prop - The name of the property.
+ * @param {Function} getVal - A function that returns the value to be set if the property does not exist.
+ * @returns {*} The value of the property in the object.
+ */
 export function getOrSet (obj, prop, getVal) {
   // If the value exists return it.
   if (has.call(obj, prop)) return obj[prop]

package/src/common/util/get-or-set.test.js

@@ -0,0 +1,58 @@
+import { getOrSet } from './get-or-set'
+
+test('should return the current value of an existing property', () => {
+  const obj = { foo: 'bar' }
+  const prop = 'foo'
+  const getVal = jest.fn()
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('bar')
+  expect(getVal).not.toHaveBeenCalled()
+})
+
+test('should set and return the value from getVal if the property does not exist', () => {
+  const obj = {}
+  const prop = 'foo'
+  const getVal = jest.fn().mockReturnValue('baz')
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('baz')
+  expect(getVal).toHaveBeenCalled()
+  expect(obj.foo).toBe('baz')
+})
+
+test('should set the property as non-enumerable if Object.defineProperty is supported', () => {
+  const obj = {}
+  const prop = 'foo'
+  const getVal = jest.fn().mockReturnValue('baz')
+
+  jest.spyOn(Object, 'defineProperty')
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('baz')
+  expect(Object.defineProperty).toHaveBeenCalledWith(obj, prop, {
+    value: 'baz',
+    writable: true,
+    enumerable: false
+  })
+})
+
+test('should set the property from getVal if Object.defineProperty and Object.keys are not supported', () => {
+  const obj = {}
+  const prop = 'foo'
+  const getVal = jest.fn(() => 'baz')
+
+  const originalFn = Object.defineProperty
+  Object.defineProperty = null
+
+  const result = getOrSet(obj, prop, getVal)
+
+  expect(result).toBe('baz')
+  expect(obj.foo).toBe('baz')
+  expect(Object.prototype.propertyIsEnumerable.call(obj, 'foo')).toBe(true)
+
+  Object.defineProperty = originalFn
+})

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

@@ -21,29 +21,3 @@ export let globalScope = (() => {
 })()
 
 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.
- * tests/browser/protocol.browser.js
- * tests/browser/obfuscate.browser.js
- */
-export function setScope (obj) {
-  globalScope = { ...obj }
-}
-export function resetScope () {
-  if (isBrowserScope) {
-    globalScope = window
-  } else if (isWorkerScope) {
-    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
-      globalScope = globalThis
-    } else if (self instanceof WorkerGlobalScope) {
-      globalScope = self
-    }
-  } else {
-    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 function getGlobalScope () {
-  return globalScope
-}

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

@@ -0,0 +1,87 @@
+/*
+The global-scope module contains exports that are defined once at the time
+of importing the module. For this reason, the module must be dynamically
+imported in each test case.
+
+A scope must always exist or importing the module will throw an error. Use
+`enableWorkerScope` to enable the worker scope. Be sure to call `disableWorkerScope`
+before any calls to `expect` or the test will fail with an error from Jest.
+*/
+
+import { faker } from '@faker-js/faker'
+
+afterEach(() => {
+  jest.restoreAllMocks()
+  jest.resetModules()
+})
+
+test('should indicate a browser scope', async () => {
+  jest.spyOn(global, 'window', 'get').mockReturnValue({ document: {} })
+
+  const globalScopeModule = await import('./global-scope')
+
+  expect(globalScopeModule.isBrowserScope).toBe(true)
+  expect(globalScopeModule.isWorkerScope).toBe(false)
+  expect(globalScopeModule.globalScope).toBe(global.window)
+})
+
+test('should indicate a worker scope', async () => {
+  enableWorkerScope()
+  const globalScopeModule = await import('./global-scope')
+  const mockedGlobalThis = global.globalThis
+  disableWorkerScope()
+
+  expect(globalScopeModule.isBrowserScope).toBe(false)
+  expect(globalScopeModule.isWorkerScope).toBe(true)
+  expect(globalScopeModule.globalScope).toBe(mockedGlobalThis)
+})
+
+test('should return the self global', async () => {
+  enableWorkerScope()
+  jest.replaceProperty(global, 'globalThis', null)
+  jest.spyOn(global, 'self', 'get').mockReturnValue(new global.WorkerGlobalScope())
+
+  const globalScopeModule = await import('./global-scope')
+  const mockedGlobalSelf = global.self
+  disableWorkerScope()
+
+  expect(globalScopeModule.isBrowserScope).toBe(false)
+  expect(globalScopeModule.isWorkerScope).toBe(true)
+  expect(globalScopeModule.globalScope).toBe(mockedGlobalSelf)
+})
+
+test('should throw an error when a scope cannot be defined', async () => {
+  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined)
+
+  await expect(() => import('./global-scope')).rejects.toThrow()
+})
+
+test('should immediately store the current location', async () => {
+  const url = faker.internet.url()
+  jest.spyOn(window, 'location', 'get').mockReturnValue(url)
+
+  const globalScopeModule = await import('./global-scope')
+
+  expect(globalScopeModule.initialLocation).toBe(url)
+})
+
+function enableWorkerScope () {
+  jest.spyOn(global, 'window', 'get').mockReturnValue(undefined)
+
+  class WorkerNavigator {}
+  class WorkerGlobalScope {
+    navigator = new WorkerNavigator()
+  }
+  global.WorkerGlobalScope = WorkerGlobalScope
+  global.WorkerNavigator = WorkerNavigator
+
+  jest.spyOn(global, 'navigator', 'get').mockReturnValue(new global.WorkerNavigator())
+  jest.replaceProperty(global, 'globalThis', new WorkerGlobalScope())
+}
+
+function disableWorkerScope () {
+  delete global.WorkerGlobalScope
+  delete global.WorkerNavigator
+
+  jest.restoreAllMocks()
+}