@newrelic/browser-agent 0.1.230 → 1.232.0

package/src/common/timer/timer.js

@@ -0,0 +1,31 @@
+
+export class Timer {
+  constructor (opts, ms) {
+    if (!opts.onEnd) throw new Error('onEnd handler is required')
+    if (!ms) throw new Error('ms duration is required')
+    this.onEnd = opts.onEnd
+    this.initialMs = ms
+    this.startTimestamp = Date.now()
+
+    this.timer = this.create(this.onEnd, ms)
+  }
+
+  create (cb, ms) {
+    if (this.timer) this.clear()
+    return setTimeout(() => cb ? cb() : this.onEnd(), ms || this.initialMs)
+  }
+
+  clear () {
+    clearTimeout(this.timer)
+    this.timer = null
+  }
+
+  end () {
+    this.clear()
+    this.onEnd()
+  }
+
+  isValid () {
+    return this.initialMs - (Date.now() - this.startTimestamp) > 0
+  }
+}

package/src/common/timer/timer.test.js

@@ -0,0 +1,100 @@
+import { Timer } from './timer'
+
+jest.useFakeTimers()
+
+let now
+
+beforeEach(() => {
+  now = Date.now()
+  jest.setSystemTime(now)
+})
+
+afterEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('constructor', () => {
+  test('appropriate properties are set with valid values -- no refresh', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('appropriate properties are set with valid values -- with refresh', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    const requiredKeys = ['onEnd', 'initialMs', 'startTimestamp', 'timer']
+    expect(requiredKeys.every(rk => !!timer[rk])).toBeTruthy()
+  })
+
+  test('required keys are enforced', () => {
+    try {
+      new Timer({}, 100)
+    } catch (e) {
+      expect(e).toEqual(new Error('onEnd handler is required'))
+    }
+
+    try {
+      new Timer({ onEnd: jest.fn() })
+    } catch (e) {
+      expect(e).toEqual(new Error('ms duration is required'))
+    }
+  })
+})
+
+describe('create()', () => {
+  test('Create sets a timeout that can execute a cb', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.timer).toBeTruthy()
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    jest.runOnlyPendingTimers()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+  })
+
+  test('Create can fallback to use defaults', () => {
+    let called = 0
+    const timer1 = new Timer({ onEnd: jest.fn() }, 100)
+    timer1.create()
+
+    const timer2 = new Timer({ onEnd: jest.fn() }, 100)
+    timer2.create(timer2.onEnd)
+
+    const timer3 = new Timer({ onEnd: jest.fn() }, 100)
+    timer3.create(undefined, 100)
+
+    jest.runAllTimers(200)
+
+    expect(timer1.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer2.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer3.onEnd).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('clear()', () => {
+  test('clear prevents the callback from firing and deletes the pointer', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.clear()
+    jest.advanceTimersByTime(150)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('end()', () => {
+  test('end clears the callback and calls the onEnd callback', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.onEnd).toHaveBeenCalledTimes(0)
+    timer.end()
+    expect(timer.onEnd).toHaveBeenCalledTimes(1)
+    expect(timer.timer).toEqual(null)
+  })
+})
+
+describe('isValid', () => {
+  test('isValid validates timeStamps', () => {
+    const timer = new Timer({ onEnd: jest.fn() }, 100)
+    expect(timer.isValid()).toEqual(true)
+    timer.startTimestamp -= 100
+    expect(timer.isValid()).toEqual(false)
+  })
+})

package/src/common/timing/nav-timing.js

@@ -27,44 +27,64 @@ var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent'
 
 export var navTimingValues = []
 
-export function addPT (offset, pt, v) {
+function getPntType (type) {
+  if (typeof type == 'number') return type
+  const types = {
+    navigate: undefined,
+    reload: 1,
+    back_forward: 2,
+    prerender: 3
+  }
+  return types[type]
+}
+
+export function addPT (offset, pt, v = {}, isL1Api = false) {
+  if (!pt) return
   v.of = offset
-  addRel(offset, offset, v, 'n')
-  addRel(pt[UNLOAD_EVENT + START], offset, v, 'u')
-  addRel(pt[REDIRECT + START], offset, v, 'r')
-  addRel(pt[UNLOAD_EVENT + END], offset, v, 'ue')
-  addRel(pt[REDIRECT + END], offset, v, 're')
-  addRel(pt['fetch' + START], offset, v, 'f')
-  addRel(pt[DOMAIN_LOOKUP + START], offset, v, 'dn')
-  addRel(pt[DOMAIN_LOOKUP + END], offset, v, 'dne')
-  addRel(pt['c' + ONNECT + START], offset, v, 'c')
-  addRel(pt['secureC' + ONNECT + 'ion' + START], offset, v, 's')
-  addRel(pt['c' + ONNECT + END], offset, v, 'ce')
-  addRel(pt[REQUEST + START], offset, v, 'rq')
-  addRel(pt[RESPONSE + START], offset, v, 'rp')
-  addRel(pt[RESPONSE + END], offset, v, 'rpe')
-  addRel(pt.domLoading, offset, v, 'dl')
-  addRel(pt.domInteractive, offset, v, 'di')
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + START], offset, v, 'ds')
-  addRel(pt[DOM_CONTENT_LOAD_EVENT + END], offset, v, 'de')
-  addRel(pt.domComplete, offset, v, 'dc')
-  addRel(pt[LOAD_EVENT + START], offset, v, 'l')
-  addRel(pt[LOAD_EVENT + END], offset, v, 'le')
+  handleValue(v.of, v, 'n', true)
+  handleValue(pt[UNLOAD_EVENT + START], v, 'u', isL1Api)
+  handleValue(pt[REDIRECT + START], v, 'r', isL1Api)
+  handleValue(pt[UNLOAD_EVENT + END], v, 'ue', isL1Api)
+  handleValue(pt[REDIRECT + END], v, 're', isL1Api)
+  handleValue(pt['fetch' + START], v, 'f', isL1Api)
+  handleValue(pt[DOMAIN_LOOKUP + START], v, 'dn', isL1Api)
+  handleValue(pt[DOMAIN_LOOKUP + END], v, 'dne', isL1Api)
+  handleValue(pt['c' + ONNECT + START], v, 'c', isL1Api)
+  handleValue(pt['secureC' + ONNECT + 'ion' + START], v, 's', isL1Api)
+  handleValue(pt['c' + ONNECT + END], v, 'ce', isL1Api)
+  handleValue(pt[REQUEST + START], v, 'rq', isL1Api)
+  handleValue(pt[RESPONSE + START], v, 'rp', isL1Api)
+  handleValue(pt[RESPONSE + END], v, 'rpe', isL1Api)
+  handleValue(pt.domLoading, v, 'dl', isL1Api)
+  handleValue(pt.domInteractive, v, 'di', isL1Api)
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + START], v, 'ds', isL1Api)
+  handleValue(pt[DOM_CONTENT_LOAD_EVENT + END], v, 'de', isL1Api)
+  handleValue(pt.domComplete, v, 'dc', isL1Api)
+  handleValue(pt[LOAD_EVENT + START], v, 'l', isL1Api)
+  handleValue(pt[LOAD_EVENT + END], v, 'le', isL1Api)
   return v
 }
 
 // Add Performance Navigation values to the given object
 export function addPN (pn, v) {
-  addRel(pn.type, 0, v, 'ty')
-  addRel(pn.redirectCount, 0, v, 'rc')
+  handleValue(getPntType(pn.type), v, 'ty')
+  handleValue(pn.redirectCount, v, 'rc')
   return v
 }
 
-export function addRel (value, offset, obj, prop) {
-  var relativeValue
-  if (typeof (value) === 'number' && (value > 0)) {
-    relativeValue = Math.max(Math.round(value - offset), 0)
-    obj[prop] = relativeValue
+function handleValue (value, obj, prop, isOldApi) {
+  /*
+  For L2 Timing API, the value will already be a relative-to-previous-document DOMHighResTimeStamp.
+  For L1 (deprecated) Timing, the value is an UNIX epoch timestamp, which we will convert to a relative time using our offset.
+  PNT.type is reported as undefined, 1, 2, etc -- note that zero-value properties will be recorded as 'undefined', however DEM interprets undefined "types" as "navigate"
+  */
+  if (typeof value === 'number' && value > 0) { // note that zero-value properties will be recorded as 'undefined'
+    if (isOldApi) {
+      const offset = obj?.of > 0 ? obj.of : 0 // expect an epoch timestamp, if called by addPT
+      value = Math.max(value - offset, 0)
+    }
+    value = Math.round(value)
+    obj[prop] = value
   }
-  navTimingValues.push(relativeValue)
+  navTimingValues.push(value)
 }

package/src/common/timing/nav-timing.test.js

@@ -0,0 +1,161 @@
+import { addPT, addPN, navTimingValues } from './nav-timing'
+
+const offset = 123
+const testValues = {
+  unloadEventStart: 1,
+  redirectStart: 2,
+  unloadEventEnd: 3,
+  redirectEnd: 4,
+  fetchStart: 5,
+  domainLookupStart: 6,
+  domainLookupEnd: 7,
+  connectStart: 8,
+  secureConnectionStart: 9,
+  connectEnd: 10,
+  requestStart: 11,
+  responseStart: 12,
+  responseEnd: 13,
+  domLoading: 14,
+  domInteractive: 15,
+  domContentLoadedEventStart: 16,
+  domContentLoadedEventEnd: 17,
+  domComplete: 18,
+  loadEventStart: 19,
+  loadEventEnd: 20,
+  type: 'reload',
+  redirectCount: 22
+}
+
+const legacyTestValues = {
+  unloadEventStart: offset + 1,
+  redirectStart: offset + 2,
+  unloadEventEnd: offset + 3,
+  redirectEnd: offset + 4,
+  fetchStart: offset + 5,
+  domainLookupStart: offset + 6,
+  domainLookupEnd: offset + 7,
+  connectStart: offset + 8,
+  secureConnectionStart: offset + 9,
+  connectEnd: offset + 10,
+  requestStart: offset + 11,
+  responseStart: offset + 12,
+  responseEnd: offset + 13,
+  domLoading: offset + 14,
+  domInteractive: offset + 15,
+  domContentLoadedEventStart: offset + 16,
+  domContentLoadedEventEnd: offset + 17,
+  domComplete: offset + 18,
+  loadEventStart: offset + 19,
+  loadEventEnd: offset + 20,
+  type: 'reload',
+  redirectCount: offset + 22
+}
+
+const expectedPT = {
+  of: offset,
+  n: 0,
+  u: 1,
+  r: 2,
+  ue: 3,
+  re: 4,
+  f: 5,
+  dn: 6,
+  dne: 7,
+  c: 8,
+  s: 9,
+  ce: 10,
+  rq: 11,
+  rp: 12,
+  rpe: 13,
+  dl: 14,
+  di: 15,
+  ds: 16,
+  de: 17,
+  dc: 18,
+  l: 19,
+  le: 20
+}
+
+const expectedPN = {
+  ty: 1,
+  rc: 22
+}
+
+describe('addPT()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = addPT(offset, testValues, {})
+    expect(output).toEqual(expectedPT)
+  })
+
+  test('an object with invalid values is handled', () => {
+    const output = addPT(offset, { ...testValues, invalidValue: 'test' }, {})
+    expect(output).toEqual(expectedPT)
+
+    const output2 = addPT(offset, { ...testValues, loadEventEnd: -1 }, {})
+    let expected = { ...expectedPT }
+    delete expected.le
+    expect(output2).toEqual(expected)
+
+    const output3 = addPT(offset, { ...testValues, loadEventEnd: 'test' }, {})
+    expected = { ...expectedPT }
+    delete expected.le
+    expect(output3).toEqual(expected)
+
+    const output4 = addPT(offset, { ...testValues, loadEventEnd: null }, {})
+    expected = { ...expectedPT }
+    delete expected.le
+    expect(output4).toEqual(expected)
+
+    const legacyoutput = addPT(offset, { ...legacyTestValues, invalidValue: 'test' }, {}, true)
+    expect(legacyoutput).toEqual(expectedPT)
+
+    const legacyoutput2 = addPT(offset, { ...legacyTestValues, loadEventEnd: -1 }, {}, true)
+    let legacyexpected = { ...expectedPT }
+    delete legacyexpected.le
+    expect(legacyoutput2).toEqual(expected)
+
+    const legacyoutput3 = addPT(offset, { ...legacyTestValues, loadEventEnd: 'test' }, {}, true)
+    legacyexpected = { ...expectedPT }
+    delete legacyexpected.le
+    expect(legacyoutput3).toEqual(legacyexpected)
+
+    const legacyoutput4 = addPT(offset, { ...legacyTestValues, loadEventEnd: null }, {}, true)
+    legacyexpected = { ...expectedPT }
+    delete legacyexpected.le
+    expect(legacyoutput4).toEqual(legacyexpected)
+  })
+
+  test('rounds values to integers', () => {
+    const output = addPT(offset, { unloadEventStart: 3.14159 }, {})
+    expect(output.u).toEqual(3)
+
+    const legacyoutput = addPT(0, { unloadEventStart: 3.14159 }, {}, true)
+    expect(legacyoutput.u).toEqual(3)
+  })
+
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = navTimingValues.length
+    addPT(offset, { testValues }, {})
+    const afterLength = navTimingValues.length
+    expect(afterLength - beforeLength).toEqual(21) // 20 + value of n
+
+    const legacybeforeLength = navTimingValues.length
+    addPT(offset, { legacyTestValues }, {}, true)
+    const legacyafterLength = navTimingValues.length
+    expect(legacyafterLength - legacybeforeLength).toEqual(21) // 20 + value of n
+  })
+})
+
+describe('addPN()', () => {
+  test('an output object is populated with valid values', () => {
+    const output = addPN(testValues, {})
+    expect(output).toEqual(expectedPN)
+  })
+
+  test('adds entries to navTimingValues', () => {
+    const beforeLength = navTimingValues.length
+    addPN(offset, { testValues }, {})
+    const afterLength = navTimingValues.length
+    expect(afterLength - beforeLength).toEqual(2)
+  })
+})

package/src/common/unload/eol.js

@@ -4,7 +4,7 @@
  */
 import { ffVersion } from '../browser-version/firefox-version'
 import { windowAddEventListener } from '../event-listener/event-listener-opts'
-import { single } from '../util/single'
+import { single } from '../util/invoke'
 import { globalScope, isWorkerScope, isBrowserScope } from '../util/global-scope'
 import { subscribeToVisibilityChange } from '../window/page-visibility'
 
@@ -55,8 +55,7 @@ export function subscribeToEOL (cb, allowBFCache) {
       }
       windowAddEventListener('unload', oneCall)
     }
-  }
-  else if (isWorkerScope) {
+  } else if (isWorkerScope) {
     globalScope.cleanupTasks.push(cb) // close() should run these tasks before quitting thread
   }
   // By default (for other env), this fn has no effect.

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

@@ -0,0 +1,25 @@
+import { cleanURL } from './clean-url'
+
+test.each([
+  ['http://domain.com/path?query=5', 'http://domain.com/path'],
+  ['http://domain.com/path#fragment', 'http://domain.com/path'],
+  ['http://domain.com/path?query=5#fragment', 'http://domain.com/path'],
+  ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path'],
+  ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path'],
+  ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path'],
+  ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path']
+])('cleanURL should remove hash', (input, expected) => {
+  expect(cleanURL(input)).toEqual(expected)
+})
+
+test.each([
+  ['http://domain.com/path?query=5', 'http://domain.com/path'],
+  ['http://domain.com/path#fragment', 'http://domain.com/path#fragment'],
+  ['http://domain.com/path?query=5#fragment', 'http://domain.com/path#fragment'],
+  ['http://domain.com/path?query=5?dumb#fragment', 'http://domain.com/path#fragment'],
+  ['http://domain.com/path?query=5#fragment#dumb', 'http://domain.com/path#fragment#dumb'],
+  ['http://domain.com/path?query=5#fragment#dumb?additional_query', 'http://domain.com/path#fragment#dumb'],
+  ['http://domain.com/path?query=5#fragment/silly/dumber#dumbest?additional_query=silly#what_is_this_even', 'http://domain.com/path#fragment/silly/dumber#dumbest']
+])('cleanURL should retain hash if second argument is true', (input, expected) => {
+  expect(cleanURL(input, true)).toEqual(expected)
+})

package/src/common/url/encode.test.js

@@ -0,0 +1,80 @@
+import * as encode from './encode'
+
+describe('query string encoding', () => {
+  test('escapes string components except safe characters', () => {
+    const input = 'Asdf:, :, /@$;'
+    const expected = 'Asdf:,%20:,%20/@$;'
+
+    expect(encode.qs(input)).toEqual(expected)
+  })
+
+  test('null and undefined value returns \'null\'', () => {
+    expect(encode.qs(null)).toEqual('null')
+    expect(encode.qs(undefined)).toEqual('null')
+  })
+})
+
+describe('fromArray encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = ['a', 'b', 'c']
+    const expected = 'ab'
+
+    expect(encode.fromArray(input, 2)).toEqual(expected)
+  })
+
+  test('fall back to largest whole chunk', () => {
+    const input = ['aa', 'bb', 'cc']
+    const expected = 'aabb'
+
+    expect(encode.fromArray(input, 5)).toEqual(expected)
+  })
+})
+
+describe('object encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = { foo: [1, 2, 3] }
+    const expected = '&foo=%5B1,2%5D'
+
+    expect(encode.obj(input, 12)).toEqual(expected)
+  })
+
+  test('fall back to largest whole chunk', () => {
+    const input = { bar: ['a', 'b', 'c'] }
+    const expected = '&bar=%5B%22a%22,%22b%22%5D'
+
+    expect(encode.obj(input, 30)).toEqual(expected)
+  })
+
+  test('handles circular objects', () => {
+    const circular = {}
+    circular.circular = circular
+    const input = { bar: ['a', circular, 'c'] }
+    const expected = '&bar=%5B%22a%22,%7B%7D,%22c%22%5D'
+
+    expect(encode.obj(input, 1000)).toEqual(expected)
+  })
+
+  test('handles circular arrays', () => {
+    const circular = []
+    circular.push(circular)
+    const input = { bar: ['a', circular, 'c'] }
+    const expected = '&bar=%5B%22a%22,%5Bnull%5D,%22c%22%5D'
+
+    expect(encode.obj(input, 1000)).toEqual(expected)
+  })
+})
+
+describe('encode key value pairs as query params', () => {
+  test('ignores input when value is null or undefined', () => {
+    expect(encode.param('foo', null)).toEqual('')
+    expect(encode.param('foo', undefined)).toEqual('')
+  })
+
+  test('encodes key value pair correctly', () => {
+    expect(encode.param('foo', 'bar')).toEqual('&foo=bar')
+  })
+
+  test('ignores input when value is not a string', () => {
+    expect(encode.param('foo', {})).toEqual('')
+  })
+})

package/src/common/url/location.js

@@ -3,6 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * This method only exists to support testing in JIL and can be removed once tests are migrated to WDIO.
+ * @returns global scope location
+ */
 export function getLocation () {
   return '' + location
 }

package/src/common/url/location.test.js

@@ -0,0 +1,15 @@
+import { faker } from '@faker-js/faker'
+import { getLocation } from './location'
+
+test('should always return a string', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({})
+
+  expect(typeof getLocation()).toEqual('string')
+})
+
+test('should return window location', () => {
+  const expected = faker.internet.url()
+  jest.spyOn(window, 'location', 'get').mockReturnValue(expected)
+
+  expect(getLocation()).toEqual(expected)
+})

package/src/common/url/parse-url.js

@@ -27,8 +27,7 @@ export function parseUrl (url) {
     // Use an anchor dom element to resolve the url natively.
     urlEl = document.createElement('a')
     urlEl.href = url
-  }
-  else {
+  } else {
     try {
       urlEl = new URL(url, location.href)
     } catch (err) {

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

@@ -0,0 +1,110 @@
+afterEach(() => {
+  jest.resetModules()
+  jest.clearAllMocks()
+})
+
+const urlTests = [
+  {
+    input: 'http://example.com/path/name?qs=5&a=b',
+    expected: {
+      hostname: 'example.com',
+      pathname: '/path/name',
+      protocol: 'http',
+      port: '80',
+      sameOrigin: false
+    }
+  },
+  {
+    input: 'http://foo:bar@example.com:8080/path/@name?qs=5&a=b',
+    expected: {
+      hostname: 'example.com',
+      pathname: '/path/@name',
+      protocol: 'http',
+      port: '8080',
+      sameOrigin: false
+    }
+  },
+  {
+    input: 'https://foo:bar@example.com/path/name?qs=5&a=b',
+    expected: {
+      hostname: 'example.com',
+      pathname: '/path/name',
+      protocol: 'https',
+      port: '443',
+      sameOrigin: false
+    }
+  },
+  {
+    input: '/path/name?qs=5&a=b',
+    expected: {
+      hostname: location.hostname,
+      pathname: '/path/name',
+      protocol: location.protocol.split(':')[0],
+      port: '80',
+      sameOrigin: true
+    }
+  },
+  {
+    input: location.protocol + '//' + location.hostname + ':' + location.port + '/path/name?qs=5&a=b',
+    expected: {
+      hostname: location.hostname,
+      pathname: '/path/name',
+      protocol: location.protocol.split(':')[0],
+      port: '80',
+      sameOrigin: true
+    }
+  },
+  {
+    input: 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==',
+    expected: {
+      protocol: 'data'
+    }
+  }
+]
+
+test.each(urlTests)('verify url parsing inside browser scope', async ({ input, expected }) => {
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: true,
+    globalScope: global
+  }))
+
+  const { parseUrl } = await import('./parse-url')
+  expect(parseUrl(input)).toEqual(expected)
+})
+
+test.each(urlTests)('verify url parsing outside browser scope', async ({ input, expected }) => {
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: false,
+    globalScope: global
+  }))
+
+  const { parseUrl } = await import('./parse-url')
+  expect(parseUrl(input)).toEqual(expected)
+})
+
+test('should cache parsed urls', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: true,
+    globalScope: global
+  }))
+
+  const input = 'http://example.com/'
+  const expected = {
+    hostname: 'example.com',
+    pathname: '/',
+    protocol: 'http',
+    port: '80',
+    sameOrigin: false
+  }
+
+  jest.spyOn(document, 'createElement')
+
+  const { parseUrl } = await import('./parse-url')
+  parseUrl(input)
+
+  expect(parseUrl(input)).toEqual(expected)
+  expect(document.createElement).toHaveBeenCalledTimes(1)
+})

package/src/common/url/protocol.js

@@ -2,18 +2,8 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getGlobalScope } from '../util/global-scope'
+import { globalScope } from '../util/global-scope'
 
-export const protocol = {
-  isFileProtocol: isFileProtocol,
-  supportabilityMetricSent: false
-}
-
-function isFileProtocol () {
-  let isFile = Boolean(getGlobalScope()?.location?.protocol === 'file:')
-  if (isFile) {
-    //metrics.recordSupportability('Generic/FileProtocol/Detected') -- may be implemented later? Probably make sure it's once per window
-    protocol.supportabilityMetricSent = true
-  }
-  return isFile
+export function isFileProtocol () {
+  return Boolean(globalScope?.location?.protocol === 'file:')
 }