@newrelic/browser-agent 1.237.0 → 1.238.0

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

@@ -7,7 +7,9 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-export const flag = 'nr@original'
+import { bundleId } from '../ids/bundle-id'
+
+export const flag = `nr@original:${bundleId}`
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -107,26 +109,24 @@ export function createWrapperWithEmitter (emitter, always) {
 
   /**
    * Creates wrapper functions around each of an array of methods on a specified object.
-   * @param {Object} obj - The object to which the specified methods belong.
-   * @param {string[]} methods - An array of method names to be wrapped.
-   * @param {string} [prefix=''] - A prefix to add to the names of emitted events. If `-` is the first character, also
-   *     adds the method name before the prefix.
-   * @param {function|object} [getContext] - The function or object that will serve as the 'this' context for handlers
-   *     of events emitted by this wrapper.
-   * @param {boolean} [bubble=false] - If `true`, emitted events should also bubble up to the old emitter upon which
-   *     the `emitter` in the current scope was based (if it defines one).
+   * @param {Object} obj The object to which the specified methods belong.
+   * @param {string[]} methods An array of method names to be wrapped.
+   * @param {string} [prefix=''] A prefix to add to the names of emitted events. If `-` is the first character, also
+   * adds the method name before the prefix.
+   * @param {function|object} [getContext] The function or object that will serve as the 'this' context for handlers
+   * of events emitted by this wrapper.
+   * @param {boolean} [bubble=false] If `true`, emitted events should also bubble up to the old emitter upon which
+   * the `emitter` in the current scope was based (if it defines one).
    */
   function inPlace (obj, methods, prefix, getContext, bubble) {
     if (!prefix) prefix = ''
+
     // If prefix starts with '-' set this boolean to add the method name to the prefix before passing each one to wrap.
-    var prependMethodPrefix = (prefix.charAt(0) === '-')
-    var fn
-    var method
-    var i
+    const prependMethodPrefix = (prefix.charAt(0) === '-')
 
-    for (i = 0; i < methods.length; i++) {
-      method = methods[i]
-      fn = obj[method]
+    for (let i = 0; i < methods.length; i++) {
+      const method = methods[i]
+      const fn = obj[method]
 
       // Unless fn is both wrappable and unwrapped, bail so we don't add extra properties with undefined values.
       if (notWrappable(fn)) continue
@@ -217,31 +217,3 @@ function copy (from, to, emitter) {
 function notWrappable (fn) {
   return !(fn && fn instanceof Function && fn.apply && !fn[flag])
 }
-
-/**
- * Creates a wrapped version of a function using a specified wrapper function. The new wrapped function references the
- * original function. Also copies the properties of the original function to the wrapped function.
- * @param {function} fn - A function to be wrapped.
- * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
- *     to the higher order function as an argument.
- * @returns {function} A wrapped function with an internal reference to the original function.
- */
-export function wrapFunction (fn, wrapper) {
-  var wrapped = wrapper(fn)
-  wrapped[flag] = fn
-  copy(fn, wrapped, ee)
-  return wrapped
-}
-
-/**
- * Replaces a function with a wrapped version of itself. To preserve object references, rather than taking the function
- * itself as an argument, takes the object on which the particular named function is a property.
- * @param {Object} obj - The object on which the named function is a property.
- * @param {string} fnName - The name of the function to be wrapped.
- * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
- *     to the higher order function as an argument.
- */
-export function wrapInPlace (obj, fnName, wrapper) {
-  var fn = obj[fnName]
-  obj[fnName] = wrapFunction(fn, wrapper)
-}

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

@@ -9,8 +9,7 @@
 
 import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
-import { originals } from '../config/config'
-import { isBrowserScope } from '../constants/runtime'
+import { globalScope, isBrowserScope } from '../constants/runtime'
 
 const wrapped = {}
 
@@ -30,7 +29,7 @@ export function wrapMutation (sharedEE) {
   wrapped[ee.debugId] = true // otherwise, first feature to wrap mutations
 
   var wrapFn = wfn(ee)
-  var OriginalObserver = originals.MO
+  var OriginalObserver = globalScope.MutationObserver
 
   if (OriginalObserver) {
     window.MutationObserver = function WrappedMutationObserver (cb) {

package/src/common/wrap/{wrap-promise.test.js → wrap-promise.component-test.js}

@@ -1,35 +1,5 @@
 import { faker } from '@faker-js/faker'
 import { globalScope } from '../constants/runtime'
-import { originals } from '../config/config'
-
-jest.mock('./wrap-function', () => ({
-  __esModule: true,
-  createWrapperWithEmitter: jest.fn(() => (fn) => (...args) => {
-    return fn.apply(null, args)
-  })
-}))
-jest.mock('../event-emitter/contextual-ee', () => ({
-  __esModule: true,
-  getOrSetContext: jest.fn(() => ({})),
-  ee: {
-    get: jest.fn((name) => ({
-      debugId: name,
-      on: jest.fn(),
-      context: jest.fn(() => ({})),
-      emit: jest.fn()
-    }))
-  }
-}))
-jest.mock('../config/config', () => ({
-  __esModule: true,
-  originals: {}
-}))
-jest.mock('../constants/runtime', () => ({
-  __esModule: true,
-  globalScope: {
-    NREUM: {}
-  }
-}))
 
 let promiseConstructorCalls
 
@@ -38,7 +8,7 @@ beforeEach(async () => {
 
   // Proxy the global Promise to prevent the wrapping from
   // messing with Jest internal promises
-  originals.PR = new Proxy(class extends Promise {}, {
+  window.Promise = new Proxy(class extends Promise {}, {
     construct (target, args) {
       promiseConstructorCalls.push(args)
 
@@ -57,7 +27,7 @@ test('should wrap promise constructor', async () => {
   const promiseInstance = new globalScope.Promise(jest.fn())
 
   expect(promiseInstance).toBeInstanceOf(Promise)
-  expect(promiseConstructorCalls.length).toEqual(1)
+  expect(promiseConstructorCalls.length).toBeGreaterThan(0)
   expect(globalScope.Promise.toString()).toMatch(/\[native code\]/)
   expect(globalScope.Promise.name).toEqual('Promise')
 })

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

@@ -8,8 +8,7 @@
  */
 
 import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function'
-import { ee as baseEE, getOrSetContext } from '../event-emitter/contextual-ee'
-import { originals } from '../config/config'
+import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
 
 const wrapped = {}
@@ -29,9 +28,9 @@ export function wrapPromise (sharedEE) {
   if (wrapped[promiseEE.debugId]) return promiseEE
   wrapped[promiseEE.debugId] = true // otherwise, first feature to wrap promise
 
-  var getContext = getOrSetContext
+  var getContext = promiseEE.context
   var promiseWrapper = wrapFn(promiseEE)
-  var prevPromiseObj = originals.PR
+  var prevPromiseObj = globalScope.Promise
 
   if (prevPromiseObj) { // ensure there's a Promise API (native or otherwise) to even wrap
     wrap()

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

@@ -11,7 +11,6 @@ import { wrapEvents } from './wrap-events'
 import { ee as contextualEE } from '../event-emitter/contextual-ee'
 import { eventListenerOpts } from '../event-listener/event-listener-opts'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
-import { originals } from '../config/config'
 import { globalScope } from '../constants/runtime'
 import { warn } from '../util/console'
 
@@ -37,37 +36,33 @@ export function wrapXhr (sharedEE) {
   wrapEvents(baseEE) // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = wfn(ee)
 
-  var OrigXHR = originals.XHR
-  var MutationObserver = originals.MO
-  var Promise = originals.PR
-  var setImmediate = originals.SI
+  var OrigXHR = globalScope.XMLHttpRequest
+  var MutationObserver = globalScope.MutationObserver
+  var Promise = globalScope.Promise
+  var setImmediate = globalScope.setInterval
 
   var READY_STATE_CHANGE = 'readystatechange'
 
   var handlers = ['onload', 'onerror', 'onabort', 'onloadstart', 'onloadend', 'onprogress', 'ontimeout']
   var pendingXhrs = []
 
-  var activeListeners = globalScope.XMLHttpRequest.listeners
-
   var XHR = globalScope.XMLHttpRequest = newXHR
 
   function newXHR (opts) {
-    var xhr = new OrigXHR(opts)
-    this.listeners = activeListeners ? [...activeListeners, intercept] : [intercept]
-    function intercept () {
+    const xhr = new OrigXHR(opts)
+    const context = ee.context(xhr)
+
+    try {
+      ee.emit('new-xhr', [xhr], context)
+      xhr.addEventListener(READY_STATE_CHANGE, wrapXHR(context), eventListenerOpts(false))
+    } catch (e) {
+      warn('An error occurred while intercepting XHR', e)
       try {
-        ee.emit('new-xhr', [xhr], xhr)
-        xhr.addEventListener(READY_STATE_CHANGE, wrapXHR, eventListenerOpts(false))
-      } catch (e) {
-        warn('An error occured while intercepting XHR', e)
-        try {
-          ee.emit('internal-error', [e])
-        } catch (err) {
-          // do nothing
-        }
+        ee.emit('internal-error', [e])
+      } catch (err) {
+        // do nothing
       }
     }
-    this.listeners.forEach(listener => listener())
     return xhr
   }
 
@@ -87,16 +82,17 @@ export function wrapXhr (sharedEE) {
     wrapFn.inPlace(xhr, ['onreadystatechange'], 'fn-', getObject)
   }
 
-  function wrapXHR () {
-    var xhr = this
-    var ctx = ee.context(xhr)
+  function wrapXHR (ctx) {
+    return function () {
+      var xhr = this
 
-    if (xhr.readyState > 3 && !ctx.resolved) {
-      ctx.resolved = true
-      ee.emit('xhr-resolved', [], xhr)
-    }
+      if (xhr.readyState > 3 && !ctx.resolved) {
+        ctx.resolved = true
+        ee.emit('xhr-resolved', [], xhr)
+      }
 
-    wrapFn.inPlace(xhr, handlers, 'fn-', getObject)
+      wrapFn.inPlace(xhr, handlers, 'fn-', getObject)
+    }
   }
 
   // Wrapping the onreadystatechange property of XHRs takes some special tricks.

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

@@ -11,10 +11,6 @@ import { stringify } from '../../../common/util/stringify'
 export class DT {
   constructor (agentIdentifier) {
     this.agentIdentifier = agentIdentifier
-    // Binds this class instance context to the following fn used in an external module (exported);
-    //  Alternatively, can make them class field arrow functions, but requires experimental features/plugin for eslint.
-    this.generateTracePayload = this.generateTracePayload.bind(this)
-    this.shouldGenerateTrace = this.shouldGenerateTrace.bind(this)
   }
 
   generateTracePayload (parsedOrigin) {

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

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