@newrelic/browser-agent 1.241.0 → 1.243.0

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

@@ -1,110 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { globalScope } from '../constants/runtime'
-
-let promiseConstructorCalls
-
-beforeEach(async () => {
-  promiseConstructorCalls = []
-
-  // Proxy the global Promise to prevent the wrapping from
-  // messing with Jest internal promises
-  window.Promise = new Proxy(class extends Promise {}, {
-    construct (target, args) {
-      promiseConstructorCalls.push(args)
-
-      return Reflect.construct(target, args)
-    }
-  })
-
-  ;(await import('./wrap-promise')).wrapPromise()
-})
-
-afterEach(() => {
-  jest.resetModules()
-})
-
-test('should wrap promise constructor', async () => {
-  const promiseInstance = new globalScope.Promise(jest.fn())
-
-  expect(promiseInstance).toBeInstanceOf(Promise)
-  expect(promiseConstructorCalls.length).toBeGreaterThan(0)
-  expect(globalScope.Promise.toString()).toMatch(/\[native code\]/)
-  expect(globalScope.Promise.name).toEqual('Promise')
-})
-
-describe('all', () => {
-  test('should work with acceptable iterables', async () => {
-    const resolveValue = faker.datatype.uuid()
-    const customIterable = new CustomIterable([
-      new globalScope.Promise(resolve => resolve(resolveValue))
-    ])
-    const arrayIterable = [
-      new globalScope.Promise(resolve => resolve(resolveValue))
-    ]
-    const setIterable = new Set()
-    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)))
-
-    await expect(globalScope.Promise.all(customIterable)).resolves.toEqual([resolveValue])
-    await expect(globalScope.Promise.all(arrayIterable)).resolves.toEqual([resolveValue])
-    await expect(globalScope.Promise.all(setIterable)).resolves.toEqual([resolveValue])
-  })
-
-  test.each([null, undefined])('should not try to iterate a non-iterable %s', async (input) => {
-    jest.spyOn(globalScope.Promise, 'resolve')
-
-    await expect(globalScope.Promise.all(input)).rejects.toThrow()
-    expect(globalScope.Promise.resolve).not.toHaveBeenCalled()
-  })
-})
-
-describe('race', () => {
-  test('should work with acceptable iterables', async () => {
-    jest.spyOn(globalScope.Promise, 'resolve')
-
-    const resolveValue = faker.datatype.uuid()
-    const customIterable = new CustomIterable([
-      new globalScope.Promise(resolve => resolve(resolveValue))
-    ])
-    const arrayIterable = [
-      new globalScope.Promise(resolve => resolve(resolveValue))
-    ]
-    const setIterable = new Set()
-    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)))
-
-    await expect(globalScope.Promise.race(customIterable)).resolves.toEqual(resolveValue)
-    await expect(globalScope.Promise.race(arrayIterable)).resolves.toEqual(resolveValue)
-    await expect(globalScope.Promise.race(setIterable)).resolves.toEqual(resolveValue)
-    expect(globalScope.Promise.resolve).toHaveBeenCalled()
-  })
-
-  test.each([null, undefined])('should not try to iterate a non-iterable %s', async (input) => {
-    jest.spyOn(globalScope.Promise, 'resolve')
-
-    await expect(globalScope.Promise.race(input)).rejects.toThrow()
-    expect(globalScope.Promise.resolve).not.toHaveBeenCalled()
-  })
-})
-
-class CustomIterable {
-  #iterables = []
-
-  constructor (iterables) {
-    this.#iterables = iterables
-  }
-
-  [Symbol.iterator] () {
-    return {
-      index: 0,
-      iterables: this.#iterables,
-      next () {
-        return {
-          done: this.index >= this.iterables.length,
-          value: this.iterables[this.index++] || undefined
-        }
-      },
-      [Symbol.iterator] () {
-        return this
-      }
-    }
-  }
-}

package/src/features/ajax/instrument/distributed-tracing.test.js

@@ -1,375 +0,0 @@
-import { faker } from '@faker-js/faker'
-import { DT } from './distributed-tracing'
-import { getLoaderConfig, getConfiguration, getConfigurationValue } from '../../../common/config/config'
-import * as runtimeModule from '../../../common/constants/runtime'
-
-jest.enableAutomock()
-jest.unmock('./distributed-tracing')
-
-let agentIdentifier
-let dtInstance
-
-beforeEach(() => {
-  agentIdentifier = faker.datatype.uuid()
-  dtInstance = new DT(agentIdentifier)
-
-  jest.mocked(getLoaderConfig).mockReturnValue({
-    accountID: '1234',
-    agentID: '5678',
-    trustKey: '1'
-  })
-})
-
-afterEach(() => {
-  jest.clearAllMocks()
-})
-
-test('newrelic header has the correct format', () => {
-  const agentConfig = {
-    distributed_tracing: { enabled: true }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-  const header = JSON.parse(atob(payload.newrelicHeader))
-
-  expect(payload.spanId).toEqual(header.d.id)
-  expect(payload.traceId).toEqual(header.d.tr)
-  expect(payload.timestamp).toEqual(header.d.ti)
-
-  const loaderConfig = getLoaderConfig()
-  expect(header.d.ty).toEqual('Browser')
-  expect(header.d.ac).toEqual(loaderConfig.accountID)
-  expect(header.d.ap).toEqual(loaderConfig.agentID)
-  expect(header.d.tk).toEqual(loaderConfig.trustKey)
-})
-
-test('newrelic header is not generated for same-origin calls when disabled in configuration', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      exclude_newrelic_header: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-
-  expect(payload.newrelicHeader).toBeUndefined()
-  expect(typeof payload.traceContextParentHeader).toEqual('string')
-  expect(typeof payload.traceContextStateHeader).toEqual('string')
-})
-
-test('newrelic header is added to cross-origin calls by default', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      allowed_origins: ['https://someotherdomain.com']
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: false,
-    hostname: 'someotherdomain.com',
-    protocol: 'https',
-    port: '443'
-  })
-
-  expect(payload.newrelicHeader).not.toBeUndefined()
-})
-
-test('newrelic header is added to cross-origin calls when enabled in configuration', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      allowed_origins: ['https://someotherdomain.com'],
-      cors_use_newrelic_header: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: false,
-    hostname: 'someotherdomain.com',
-    protocol: 'https',
-    port: '443'
-  })
-
-  expect(payload.newrelicHeader).not.toBeUndefined()
-})
-
-test('newrelic header is not added to cross-origin calls when disabled in configuration', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      allowed_origins: ['https://someotherdomain.com'],
-      cors_use_newrelic_header: false
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: false,
-    hostname: 'someotherdomain.com',
-    protocol: 'https',
-    port: '443'
-  })
-
-  expect(payload.newrelicHeader).toBeUndefined()
-})
-
-test('trace context headers are generated with the correct format', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-  const parentHeader = payload.traceContextParentHeader
-  const stateHeader = payload.traceContextStateHeader
-
-  const parentHeaderParts = parentHeader.split('-')
-  expect(parentHeaderParts[0]).toEqual('00')
-  expect(parentHeaderParts[1]).toEqual(payload.traceId)
-  expect(parentHeaderParts[2]).toEqual(payload.spanId)
-  expect(parentHeaderParts[3]).toEqual('01')
-
-  const loaderConfig = getLoaderConfig()
-  const stateHeaderKey = stateHeader.substring(0, stateHeader.indexOf('='))
-  expect(stateHeaderKey).toEqual(`${loaderConfig.trustKey}@nr`)
-
-  const stateHeaderParts = stateHeader.substring(stateHeader.indexOf('=') + 1).split('-')
-  expect(stateHeaderParts[0]).toEqual('0')
-  expect(stateHeaderParts[1]).toEqual('1')
-  expect(stateHeaderParts[2]).toEqual(loaderConfig.accountID)
-  expect(stateHeaderParts[3]).toEqual(loaderConfig.agentID)
-  expect(stateHeaderParts[4]).toEqual(payload.spanId)
-  expect(stateHeaderParts[5]).toEqual('')
-  expect(stateHeaderParts[6]).toEqual('')
-  expect(stateHeaderParts[7]).toEqual('')
-  expect(stateHeaderParts[8]).toEqual(payload.timestamp.toString())
-})
-
-test('trace context headers are not added to cross-origin calls by default', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      allowed_origins: ['https://someotherdomain.com']
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: false,
-    hostname: 'someotherdomain.com',
-    protocol: 'https',
-    port: '443'
-  })
-
-  expect(payload.traceContextParentHeader).toBeUndefined()
-  expect(payload.traceContextStateHeader).toBeUndefined()
-})
-
-test('trace context headers are added to cross-origin calls when enabled in configuration', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      allowed_origins: ['https://someotherdomain.com'],
-      cors_use_tracecontext_headers: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: false,
-    hostname: 'someotherdomain.com',
-    protocol: 'https',
-    port: '443'
-  })
-
-  expect(payload.traceContextParentHeader).not.toBeUndefined()
-  expect(payload.traceContextStateHeader).not.toBeUndefined()
-})
-
-test('trace context headers are not added to cross-origin calls when disabled in configuration', () => {
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true,
-      allowed_origins: ['https://someotherdomain.com'],
-      cors_use_tracecontext_headers: false
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: false,
-    hostname: 'someotherdomain.com',
-    protocol: 'https',
-    port: '443'
-  })
-
-  expect(payload.traceContextParentHeader).toBeUndefined()
-  expect(payload.traceContextStateHeader).toBeUndefined()
-})
-
-test('newrelic header is generated when configuration has numeric values', () => {
-  jest.mocked(getLoaderConfig).mockReturnValue({
-    accountID: 1234,
-    agentID: 5678,
-    trustKey: 1
-  })
-
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-  const header = JSON.parse(atob(payload.newrelicHeader))
-
-  expect(payload.spanId).toEqual(header.d.id)
-  expect(payload.traceId).toEqual(header.d.tr)
-  expect(payload.timestamp).toEqual(header.d.ti)
-
-  const loaderConfig = getLoaderConfig()
-  expect(header.d.ty).toEqual('Browser')
-  expect(header.d.ac).toEqual(loaderConfig.accountID.toString())
-  expect(header.d.ap).toEqual(loaderConfig.agentID.toString())
-  expect(header.d.tk).toEqual(loaderConfig.trustKey.toString())
-})
-
-test('no trace headers are generated when the loader config object is empty', () => {
-  const agentConfig = {
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-
-  expect(payload).toBeNull()
-})
-
-test.each([null, undefined])('no trace headers are generated when the loader config accountID is %s', (accountID) => {
-  jest.mocked(getLoaderConfig).mockReturnValue({
-    accountID,
-    agentID: '5678',
-    trustKey: '1'
-  })
-
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-
-  expect(payload).toBeNull()
-})
-
-test.each([null, undefined])('no trace headers are generated when the loader config agentID is %s', (agentID) => {
-  jest.mocked(getLoaderConfig).mockReturnValue({
-    accountID: '1234',
-    agentID,
-    trustKey: '1'
-  })
-
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-
-  expect(payload).toBeNull()
-})
-
-test.each([null, undefined])('trace headers are generated without trust key when the loader config trustKey is %s', (trustKey) => {
-  jest.mocked(getLoaderConfig).mockReturnValue({
-    accountID: '1234',
-    agentID: '5678',
-    trustKey
-  })
-
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-  const header = JSON.parse(atob(payload.newrelicHeader))
-
-  expect(payload.spanId).toEqual(header.d.id)
-  expect(payload.traceId).toEqual(header.d.tr)
-  expect(payload.timestamp).toEqual(header.d.ti)
-
-  const loaderConfig = getLoaderConfig()
-  expect(header.d.ty).toEqual('Browser')
-  expect(header.d.ac).toEqual(loaderConfig.accountID.toString())
-  expect(header.d.ap).toEqual(loaderConfig.agentID.toString())
-  expect(header.d.tk).toBeUndefined()
-})
-
-test.each([null, undefined])('newrelic header is not added when btoa global is %s', (replacementBTOA) => {
-  jest.replaceProperty(runtimeModule, 'globalScope', {
-    btoa: replacementBTOA
-  })
-
-  const agentConfig = {
-    distributed_tracing: {
-      enabled: true
-    }
-  }
-  jest.mocked(getConfiguration).mockReturnValue(agentConfig)
-  jest.mocked(getConfigurationValue).mockReturnValue(agentConfig.distributed_tracing)
-
-  const payload = dtInstance.generateTracePayload({
-    sameOrigin: true
-  })
-
-  expect(typeof payload.spanId).toEqual('string')
-  expect(typeof payload.traceId).toEqual('string')
-  expect(typeof payload.timestamp).toEqual('number')
-  expect(typeof payload.traceContextParentHeader).toEqual('string')
-  expect(typeof payload.traceContextStateHeader).toEqual('string')
-  expect(payload.header).toBeUndefined()
-})

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

@@ -1,13 +0,0 @@
-import { canonicalFunctionName } from './canonical-function-name'
-
-test.each([
-  { input: null, expected: undefined, title: 'Return undefined if no function name' },
-  { input: 'test', expected: 'test', title: 'Simple function name' },
-  { input: 'scope1/scope2/func', expected: 'func', title: 'Remove Firefox scopes' },
-  { input: 'scope1.func', expected: 'func', title: 'Remove Chrome scopes' },
-  { input: '<anonymous>', expected: undefined, title: 'Return undefined ending is non-alphanumeric' }
-])('$title', ({ input, expected }) => {
-  const result = canonicalFunctionName(input)
-
-  expect(result).toEqual(expected)
-})