@newrelic/browser-agent 0.1.230 → 0.1.231

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:')
 }

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

@@ -0,0 +1,18 @@
+import { faker } from '@faker-js/faker'
+import { isFileProtocol } from './protocol'
+
+test('should return true when location url contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'file:'
+  })
+
+  expect(isFileProtocol()).toEqual(true)
+})
+
+test('should return false when location url does not contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'http:'
+  })
+
+  expect(isFileProtocol()).toEqual(false)
+})

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

@@ -38,8 +38,7 @@ export function resetScope () {
     } else if (self instanceof WorkerGlobalScope) {
       globalScope = self
     }
-  }
-  else {
+  } 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".')
   }
 }

package/src/common/util/obfuscate.js

@@ -1,6 +1,6 @@
 import { getConfigurationValue } from '../config/config'
 import { SharedContext } from '../context/shared-context'
-import { protocol } from '../url/protocol'
+import { isFileProtocol } from '../url/protocol'
 import { warn } from './console'
 
 var fileProtocolRule = {
@@ -41,7 +41,7 @@ export function getRules (agentIdentifier) {
 
   rules = rules.concat(configRules)
 
-  if (protocol.isFileProtocol()) rules.push(fileProtocolRule)
+  if (isFileProtocol()) rules.push(fileProtocolRule)
   // could add additional runtime/environment-specific rules here
 
   return rules

package/src/common/window/page-visibility.js

@@ -17,7 +17,7 @@ export function subscribeToVisibilityChange (cb, toHiddenOnly = false) {
   function handleVisibilityChange () {
     if (toHiddenOnly) { // trigger cb on change to hidden state only
       if (document.visibilityState == 'hidden') cb()
-      else return
+      return
     }
     cb(document.visibilityState)
   }

package/src/common/wrap/index.js

@@ -2,7 +2,6 @@
  * @file Wraps assorted native objects and functions for instrumentation.
  */
 
-import { wrapConsole } from './wrap-console'
 import { wrapEvents } from './wrap-events'
 import { wrapFetch } from './wrap-fetch'
 import { wrapHistory } from './wrap-history'
@@ -14,5 +13,5 @@ import { wrapTimer } from './wrap-timer'
 import { wrapXhr } from './wrap-xhr'
 
 export {
-  wrapConsole, wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr
+  wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr
 }

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

@@ -26,16 +26,16 @@ const REMOVE_EVENT_LISTENER = 'removeEventListener'
  */
 export function wrapEvents (sharedEE) {
   var ee = scopedEE(sharedEE)
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1
 
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap events
   var wrapFn = wfn(ee, true)
 
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {
-    if (isBrowserScope)
-    { findEventListenerProtoAndCb(document, wrapNode) }
+    if (isBrowserScope) findEventListenerProtoAndCb(document, wrapNode)
     findEventListenerProtoAndCb(globalScope, wrapNode)
     findEventListenerProtoAndCb(XHR.prototype, wrapNode)
   }

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

@@ -35,9 +35,10 @@ export function wrapFetch (sharedEE) {
     return ee
   }
 
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap fetch
 
   bodyMethods.forEach(method => {
     wrapPromiseMethod(Req[proto], method, bodyPrefix)

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

@@ -21,9 +21,12 @@ const HISTORY_FNS = ['pushState', 'replaceState']
  */
 export function wrapHistory (sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (!isBrowserScope || wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime. (History API is only avail in browser DOM context.)
-  wrapped[ee.debugId] = 1
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime. History API is only
+  // available in browser DOM context.
+  if (!isBrowserScope || wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap history
 
   var wrapFn = wfn(ee)
   /*

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

@@ -24,9 +24,11 @@ const domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild']
 export function wrapJsonP (sharedEE) {
   const ee = scopedEE(sharedEE)
 
-  if (!isBrowserScope || wrapped[ee.debugId]) // JSONP deals with DOM tags so browser window env is req'd
-  { return ee }
-  wrapped[ee.debugId] = true
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.  JSONP deals with DOM
+  // tags so browser window env is required.
+  if (!isBrowserScope || wrapped[ee.debugId]) return ee
+  wrapped[ee.debugId] = true // otherwise, first feature to wrap JSONP
 
   var wrapFn = wfn(ee)
 

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

@@ -22,9 +22,12 @@ const wrapped = {}
  */
 export function wrapMutation (sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (!isBrowserScope || wrapped[ee.debugId]) // relates to the DOM tree (web env only)
-  { return ee }
-  wrapped[ee.debugId] = true
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime. Mutations API is only
+  // available in browser DOM context.
+  if (!isBrowserScope || wrapped[ee.debugId]) return ee
+  wrapped[ee.debugId] = true // otherwise, first feature to wrap mutations
 
   var wrapFn = wfn(ee)
   var OriginalObserver = originals.MO

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

@@ -24,9 +24,10 @@ const wrapped = {}
 export function wrapPromise (sharedEE) {
   const promiseEE = scopedEE(sharedEE)
 
-  if (wrapped[promiseEE.debugId])
-  { return promiseEE }
-  wrapped[promiseEE.debugId] = true
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[promiseEE.debugId]) return promiseEE
+  wrapped[promiseEE.debugId] = true // otherwise, first feature to wrap promise
 
   var getContext = getOrSetContext
   var promiseWrapper = wrapFn(promiseEE)
@@ -69,9 +70,9 @@ export function wrapPromise (sharedEE) {
       const prevStaticFn = prevPromiseObj[method]
       WrappedPromise[method] = function (subPromises) { // use our own wrapped version of "Promise.all" and ".race" static fns
         let finalized = false
-        subPromises?.forEach(sub => {
-          // eslint-disable-next-line
-          this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));
+
+        Array.from(subPromises || []).forEach(sub => {
+          this.resolve(sub).then(setNrId(method === 'all'), setNrId(false))
         })
 
         const origFnCallWithThis = prevStaticFn.apply(this, arguments)

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

@@ -0,0 +1,140 @@
+import { faker } from '@faker-js/faker'
+import { globalScope } from '../util/global-scope'
+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('../util/global-scope', () => ({
+  __esModule: true,
+  globalScope: {
+    NREUM: {}
+  }
+}))
+
+let promiseConstructorCalls
+
+beforeEach(async () => {
+  promiseConstructorCalls = []
+
+  // Proxy the global Promise to prevent the wrapping from
+  // messing with Jest internal promises
+  originals.PR = 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).toEqual(1)
+  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/common/wrap/wrap-raf.js

@@ -22,9 +22,11 @@ const RAF_NAME = 'requestAnimationFrame'
  */
 export function wrapRaf (sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (!isBrowserScope || wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime. (RAF is only avail in browser DOM context.)
-  wrapped[ee.debugId] = 1
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (!isBrowserScope || wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap RAF
 
   var wrapFn = wfn(ee)
 

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

@@ -29,9 +29,11 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
 //eslint-disable-next-line
 export function wrapTimer(sharedEE) {
   const ee = scopedEE(sharedEE)
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap timer
 
   var wrapFn = wfn(ee)
 

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

@@ -29,9 +29,10 @@ export function wrapXhr (sharedEE) {
   var baseEE = sharedEE || contextualEE
   const ee = scopedEE(baseEE)
 
-  if (wrapped[ee.debugId]++) // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-  { return ee } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1 // <- otherwise, first feature to wrap XHR
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee
+  wrapped[ee.debugId] = 1 // otherwise, first feature to wrap XHR
 
   wrapEvents(baseEE) // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = wfn(ee)

package/src/features/ajax/instrument/index.js

@@ -140,7 +140,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
         if (evt.type === 'abort' && !(context.loadCaptureCalled)) {
           context.params.aborted = true
         }
-        if (evt.type !== 'load' || (context.called === context.totalCbs) && (context.onloadCalled || typeof (xhr.onload) !== 'function') && typeof context.end === 'function') context.end(xhr)
+        if (evt.type !== 'load' || ((context.called === context.totalCbs) && (context.onloadCalled || typeof (xhr.onload) !== 'function') && typeof context.end === 'function')) context.end(xhr)
       } catch (e) {
         try {
           ee.emit('internal-error', [e])

package/src/features/jserrors/instrument/index.js

@@ -24,8 +24,10 @@ export class Instrument extends InstrumentBase {
     // skipNext counter to keep track of uncaught
     // errors that will be the same as caught errors.
     this.skipNext = 0
-    try { this.removeOnAbort = new AbortController() } // this try-catch can be removed when IE11 is completely unsupported & gone
-    catch (e) {}
+    try {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
+      this.removeOnAbort = new AbortController()
+    } catch (e) {}
 
     const thisInstrument = this
     thisInstrument.ee.on('fn-start', function (args, obj, methodName) {

package/src/features/metrics/aggregate/index.js

@@ -5,9 +5,9 @@ import { AggregateBase } from '../../utils/aggregate-base'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC, CUSTOM_METRIC, SUPPORTABILITY_METRIC_CHANNEL, CUSTOM_METRIC_CHANNEL } from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { getFrameworks } from '../../../common/metrics/framework-detection'
-import { protocol } from '../../../common/url/protocol'
+import { isFileProtocol } from '../../../common/url/protocol'
 import { getRules, validateRules } from '../../../common/util/obfuscate'
-import { VERSION } from '../../../common/constants/environment-variables'
+import { VERSION } from '../../../common/constants/env'
 import { onDOMContentLoaded } from '../../../common/window/load'
 import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
 import { isBrowserScope } from '../../../common/util/global-scope'
@@ -70,9 +70,8 @@ export class Aggregate extends AggregateBase {
     }
 
     // file protocol detection
-    if (protocol.isFileProtocol()) {
+    if (isFileProtocol()) {
       this.storeSupportabilityMetrics('Generic/FileProtocol/Detected')
-      protocol.supportabilityMetricSent = true
     }
 
     // obfuscation rules detection

package/src/features/metrics/instrument/index.js

@@ -3,42 +3,12 @@ import { insertSupportMetrics } from './workers-helper'
 import { FEATURE_NAME, SUPPORTABILITY_METRIC_CHANNEL } from '../constants'
 import { handle } from '../../../common/event-emitter/handle'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { wrapConsole } from '../../../common/wrap'
-import { stringify } from '../../../common/util/stringify'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator, auto = true) {
     super(agentIdentifier, aggregator, FEATURE_NAME, auto)
     insertSupportMetrics(tag => handle(SUPPORTABILITY_METRIC_CHANNEL, [tag], undefined, FEATURE_NAMES.metrics, this.ee))
-
-    this.addConsoleSupportabilityMetrics()
-
     this.importAggregator()
   }
-
-  addConsoleSupportabilityMetrics () {
-    // For now we are just capturing supportability metrics on `console` usage to assess log forwarding feature.
-    const consoleEE = wrapConsole(this.ee)
-
-    for (const method of ['Debug', 'Error', 'Info', 'Log', 'Trace', 'Warn']) {
-      consoleEE.on(`${method.toLowerCase()}-console-start`, function (args, target) {
-        // Parsing the args individually into a new array ensures that functions and Error objects are represented with
-        // useful string values. By default, functions stringify to null and Error objects stringify to empty objects.
-        // Note that stack traces printed by the console.trace method are not captured.
-        let parsedArgs = []
-        for (const arg of args) {
-          if (typeof arg === 'function' ||
-            (arg && arg.message && arg.stack) // Duck typing for Error objects
-          ) {
-            parsedArgs.push(arg.toString())
-          } else {
-            parsedArgs.push(arg)
-          }
-        }
-        const parsedArgsJSON = stringify(parsedArgs)
-        handle(SUPPORTABILITY_METRIC_CHANNEL, [`Console/${method}/Seen`, parsedArgsJSON.length], undefined, FEATURE_NAMES.metrics, consoleEE)
-      })
-    }
-  }
 }

package/src/features/metrics/instrument/workers-helper.js

@@ -37,23 +37,26 @@ export function insertSupportMetrics (report) {
     return // similarly, if dedicated is n/a, none of them are supported so quit
   } else {
     origWorker = Worker
-    try { globalScope.Worker = extendWorkerConstructor(origWorker, 'Dedicated') }
-    catch (e) { handleInsertionError(e, 'Dedicated') }
+    try {
+      globalScope.Worker = extendWorkerConstructor(origWorker, 'Dedicated')
+    } catch (e) { handleInsertionError(e, 'Dedicated') }
   }
 
   if (!workersApiIsSupported.shared) {
     reportUnavailable('Shared')
   } else {
     origSharedWorker = SharedWorker
-    try { globalScope.SharedWorker = extendWorkerConstructor(origSharedWorker, 'Shared') }
-    catch (e) { handleInsertionError(e, 'Shared') }
+    try {
+      globalScope.SharedWorker = extendWorkerConstructor(origSharedWorker, 'Shared')
+    } catch (e) { handleInsertionError(e, 'Shared') }
   }
   if (!workersApiIsSupported.service) {
     reportUnavailable('Service')
   } else {
     origServiceWorkerCreate = navigator.serviceWorker.register
-    try { globalScope.navigator.serviceWorker.register = extendServiceCreation(origServiceWorkerCreate) }
-    catch (e) { handleInsertionError(e, 'Service') }
+    try {
+      globalScope.navigator.serviceWorker.register = extendServiceCreation(origServiceWorkerCreate)
+    } catch (e) { handleInsertionError(e, 'Service') }
   }
   return