@newrelic/browser-agent 1.263.0 → 1.265.0

package/src/common/aggregate/aggregator.js

@@ -4,7 +4,6 @@
  */
 
 import { SharedContext } from '../context/shared-context'
-import { mapOwn } from '../util/map-own'
 
 export class Aggregator extends SharedContext {
   constructor (parent) {
@@ -34,7 +33,7 @@ export class Aggregator extends SharedContext {
     oldMetrics.count += metrics.count
 
     // iterate through each new metric and merge
-    mapOwn(metrics, function (key, value) {
+    Object.keys(metrics || {}).forEach((key) => {
       // count is a special case handled above
       if (key === 'count') return
 
@@ -94,7 +93,7 @@ export class Aggregator extends SharedContext {
 function aggregateMetrics (newMetrics, oldMetrics) {
   if (!oldMetrics) oldMetrics = { count: 0 }
   oldMetrics.count += 1
-  mapOwn(newMetrics, function (key, value) {
+  Object.entries(newMetrics || {}).forEach(([key, value]) => {
     oldMetrics[key] = updateMetric(value, oldMetrics[key])
   })
   return oldMetrics

package/src/common/config/__mocks__/info.js

@@ -0,0 +1,3 @@
+export const isValid = jest.fn()
+export const getInfo = jest.fn()
+export const setInfo = jest.fn()

package/src/common/config/__mocks__/init.js

@@ -0,0 +1,3 @@
+export const getConfiguration = jest.fn()
+export const getConfigurationValue = jest.fn()
+export const setConfiguration = jest.fn()

package/src/common/config/__mocks__/loader-config.js

@@ -0,0 +1,2 @@
+export const getLoaderConfig = jest.fn()
+export const setLoaderConfig = jest.fn()

package/src/common/config/__mocks__/runtime.js

@@ -0,0 +1,2 @@
+export const getRuntime = jest.fn()
+export const setRuntime = jest.fn()

package/src/common/config/{state/configurable.js → configurable.js}

@@ -1,4 +1,4 @@
-import { warn } from '../../util/console'
+import { warn } from '../util/console'
 
 export function getModeledObject (obj, model) {
   try {

package/src/common/config/{state/info.js → info.js}

@@ -1,4 +1,4 @@
-import { defaults as nrDefaults, getNREUMInitializedAgent } from '../../window/nreum'
+import { defaults as nrDefaults, getNREUMInitializedAgent } from '../window/nreum'
 import { getModeledObject } from './configurable'
 
 const model = {

package/src/common/config/{state/init.js → init.js}

@@ -1,8 +1,8 @@
-import { LOG_LEVELS } from '../../../features/logging/constants'
-import { isValidSelector } from '../../dom/query-selector'
-import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../../session/constants'
-import { warn } from '../../util/console'
-import { getNREUMInitializedAgent } from '../../window/nreum'
+import { LOG_LEVELS } from '../../features/logging/constants'
+import { isValidSelector } from '../dom/query-selector'
+import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../session/constants'
+import { warn } from '../util/console'
+import { getNREUMInitializedAgent } from '../window/nreum'
 import { getModeledObject } from './configurable'
 
 const nrMask = '[data-nr-mask]'
@@ -41,12 +41,13 @@ const model = () => {
       allowed_origins: undefined
     },
     feature_flags: [],
+    generic_events: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
     harvest: { tooManyRequestsDelay: 60 },
     jserrors: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
     logging: { enabled: true, harvestTimeSeconds: 10, autoStart: true, level: LOG_LEVELS.INFO },
     metrics: { enabled: true, autoStart: true },
     obfuscate: undefined,
-    page_action: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
+    page_action: { enabled: true },
     page_view_event: { enabled: true, autoStart: true },
     page_view_timing: { enabled: true, harvestTimeSeconds: 30, long_task: false, autoStart: true },
     privacy: { cookies_enabled: true }, // *cli - per discussion, default should be true

package/src/common/config/{state/loader-config.js → loader-config.js}

@@ -1,4 +1,4 @@
-import { getNREUMInitializedAgent } from '../../window/nreum'
+import { getNREUMInitializedAgent } from '../window/nreum'
 import { getModeledObject } from './configurable'
 
 const model = {

package/src/common/config/{state/runtime.js → runtime.js}

@@ -1,7 +1,13 @@
 import { getModeledObject } from './configurable'
-import { getNREUMInitializedAgent } from '../../window/nreum'
-import { globalScope, originTime } from '../../constants/runtime'
-import { BUILD_ENV, DIST_METHOD, VERSION } from '../../constants/env'
+import { getNREUMInitializedAgent } from '../window/nreum'
+import { globalScope, originTime } from '../constants/runtime'
+import { BUILD_ENV, DIST_METHOD, VERSION } from '../constants/env'
+
+/**
+ * Module level count of harvests. This property will auto-increment each time it is accessed.
+ * @type {number}
+ */
+let harvestCount = 0
 
 const readonly = {
   buildEnv: BUILD_ENV,
@@ -24,8 +30,8 @@ const model = {
   appMetadata: {},
   session: undefined,
   denyList: undefined,
-  harvestCount: 0,
-  timeKeeper: undefined
+  timeKeeper: undefined,
+  obfuscator: undefined
 }
 
 const _cache = {}
@@ -42,6 +48,14 @@ export function setRuntime (id, obj) {
     ...getModeledObject(obj, model),
     ...readonly
   }
+
+  if (!Object.hasOwnProperty.call(_cache[id], 'harvestCount')) {
+    // Harvest count needs to be added as a getter so the variable is updated each time it is accessed
+    Object.defineProperty(_cache[id], 'harvestCount', {
+      get: () => ++harvestCount
+    })
+  }
+
   const agentInst = getNREUMInitializedAgent(id)
   if (agentInst) agentInst.runtime = _cache[id]
 }

package/src/common/constants/agent-constants.js

@@ -0,0 +1,2 @@
+export const IDEAL_PAYLOAD_SIZE = 64000
+export const MAX_PAYLOAD_SIZE = 1000000

package/src/common/constants/runtime.js

@@ -72,8 +72,6 @@ export const ffVersion = (() => {
   return 0
 })()
 
-export const isIE = Boolean(isBrowserScope && window.document.documentMode) // deprecated property that only works in IE
-
 export const supportsSendBeacon = !!globalScope.navigator?.sendBeacon
 
 /**

package/src/common/drain/drain.js

@@ -4,9 +4,9 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-import { mapOwn } from '../util/map-own'
 import { registerHandler as defaultRegister } from '../event-emitter/register-handler'
 import { featurePriority } from '../../loaders/features/features'
+import { EventContext } from '../event-emitter/event-context'
 
 const registry = {}
 
@@ -102,10 +102,12 @@ function drainGroup (agentIdentifier, group, activateGroup = true) {
         emitEvent(bufferedEventsInGroup[i], groupHandlers)
       }
 
-      mapOwn(groupHandlers, function (eventType, handlerRegistrationList) {
-        mapOwn(handlerRegistrationList, function (i, registration) {
-          // registration is an array of: [targetEE, eventHandler]
-          registration[0].on(eventType, registration[1])
+      Object.entries(groupHandlers).forEach(([eventType, handlerRegistrationList]) => {
+        Object.values(handlerRegistrationList || {}).forEach((registration) => {
+          // registration *should* be an array of: [targetEE, eventHandler]
+          // certain browser polyfills of .values and .entries pass the prototype methods into the callback,
+          // which breaks this assumption and throws errors. So we make sure here that we only call .on() if its an actual NR EE
+          if (registration[0]?.on && registration[0]?.context() instanceof EventContext) registration[0].on(eventType, registration[1])
         })
       })
     }
@@ -125,7 +127,7 @@ function drainGroup (agentIdentifier, group, activateGroup = true) {
  */
 function emitEvent (evt, groupHandlers) {
   var type = evt[1]
-  mapOwn(groupHandlers[type], function (i, registration) {
+  Object.values(groupHandlers[type] || {}).forEach((registration) => {
     var sourceEE = evt[0]
     var ee = registration[0]
     if (ee === sourceEE) {

package/src/common/event-emitter/contextual-ee.js

@@ -5,7 +5,7 @@
 
 import { gosNREUM } from '../window/nreum'
 import { getOrSet } from '../util/get-or-set'
-import { getRuntime } from '../config/config'
+import { getRuntime } from '../config/runtime'
 import { EventContext } from './event-context'
 import { bundleId } from '../ids/bundle-id'
 

package/src/common/harvest/harvest.js

@@ -7,14 +7,14 @@ import { obj as encodeObj, param as encodeParam } from '../url/encode'
 import { stringify } from '../util/stringify'
 import * as submitData from '../util/submit-data'
 import { getLocation } from '../url/location'
-import { getInfo, getConfigurationValue, getRuntime, getConfiguration } from '../config/config'
+import { getInfo } from '../config/info'
+import { getConfigurationValue, getConfiguration } from '../config/init'
+import { getRuntime } from '../config/runtime'
 import { cleanURL } from '../url/clean-url'
 import { eventListenerOpts } from '../event-listener/event-listener-opts'
-import { Obfuscator } from '../util/obfuscate'
-import { applyFnToProps } from '../util/traverse'
 import { SharedContext } from '../context/shared-context'
 import { VERSION } from '../constants/env'
-import { isWorkerScope, isIE } from '../constants/runtime'
+import { isWorkerScope } from '../constants/runtime'
 import { warn } from '../util/console'
 import { now } from '../timing/now'
 
@@ -32,7 +32,7 @@ export class Harvest extends SharedContext {
     super(parent) // gets any allowed properties from the parent and stores them in `sharedContext`
 
     this.tooManyRequestsDelay = getConfigurationValue(this.sharedContext.agentIdentifier, 'harvest.tooManyRequestsDelay') || 60
-    this.obfuscator = new Obfuscator(this.sharedContext)
+    this.obfuscator = getRuntime(this.sharedContext.agentIdentifier).obfuscator
 
     this._events = {}
   }
@@ -50,7 +50,7 @@ export class Harvest extends SharedContext {
       isFinalHarvest: spec.opts?.unload === true
     }
     const payload = this.createPayload(spec.endpoint, options)
-    const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this)
+    const caller = this._send.bind(this)
     return caller({ ...spec, payload, submitMethod })
   }
 
@@ -59,21 +59,11 @@ export class Harvest extends SharedContext {
    * @param {NetworkSendSpec} spec Specification for sending data
    */
   send (spec = {}) {
-    const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this)
+    const caller = this._send.bind(this)
 
     return caller(spec)
   }
 
-  /**
-   * Apply obfuscation rules to the payload and then initial the harvest network call.
-   * @param {NetworkSendSpec} spec Specification for sending data
-   */
-  obfuscateAndSend (spec = {}) {
-    const { payload = {} } = spec
-    applyFnToProps(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e'])
-    return this._send({ ...spec, payload })
-  }
-
   /**
    * Initiate a harvest call. Typically used by `sendX` and `send` methods or called directly
    * for raw network calls.
@@ -137,8 +127,8 @@ export class Harvest extends SharedContext {
     /* Since workers don't support sendBeacon right now, they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
         we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon.
-       Following the removal of img-element method, IE will also use sync XHR on page dismissal to ensure final analytics are sent. */
-    let result = submitMethod({ url: fullUrl, body, sync: opts.unload && (isWorkerScope || isIE), headers })
+       Following the removal of img-element method. */
+    let result = submitMethod({ url: fullUrl, body, sync: opts.unload && (isWorkerScope), headers })
 
     if (!opts.unload && cbFinished && submitMethod === submitData.xhr) {
       const harvestScope = this
@@ -160,9 +150,6 @@ export class Harvest extends SharedContext {
       }, eventListenerOpts(false))
     }
 
-    const runtime = getRuntime(this.sharedContext.agentIdentifier)
-    runtime.harvestCount++
-
     return result
   }
 
@@ -171,8 +158,7 @@ export class Harvest extends SharedContext {
     const runtime = getRuntime(this.sharedContext.agentIdentifier)
     const info = getInfo(this.sharedContext.agentIdentifier)
 
-    const location = cleanURL(getLocation())
-    const ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location
+    const ref = this.obfuscator.obfuscateString(cleanURL(getLocation()))
     const hr = runtime?.session?.state.sessionReplayMode === 1 && endpoint !== 'jserrors'
 
     const qps = [

package/src/common/serialize/bel-serializer.js

@@ -3,9 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { mapOwn } from '../util/map-own'
 import { stringify } from '../util/stringify'
-import { Obfuscator } from '../util/obfuscate'
+import { getRuntime } from '../config/runtime'
 
 var hasOwnProp = Object.prototype.hasOwnProperty
 var MAX_ATTRIBUTES = 64
@@ -24,17 +23,15 @@ export function numeric (n, noDefault) {
 }
 
 export function getAddStringContext (agentIdentifier) {
-  // eslint-disable-next-line
-  var stringTable = Object.hasOwnProperty('create') ? Object.create(null) : {}
-  var stringTableIdx = 0
+  let stringTableIdx = 0
+  const stringTable = Object.prototype.hasOwnProperty.call(Object, 'create') ? Object.create(null) : {}
+  const obfuscator = getRuntime(agentIdentifier).obfuscator
 
   return addString
 
   function addString (str) {
     if (typeof str === 'undefined' || str === '') return ''
-    var obfuscator = new Obfuscator({ agentIdentifier })
-    str = String(str)
-    if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str)
+    str = obfuscator.obfuscateString(String(str))
     if (hasOwnProp.call(stringTable, str)) {
       return numeric(stringTable[str], true)
     } else {
@@ -47,7 +44,7 @@ export function getAddStringContext (agentIdentifier) {
 export function addCustomAttributes (attrs, addString) {
   var attrParts = []
 
-  mapOwn(attrs, function (key, val) {
+  Object.entries(attrs || {}).forEach(([key, val]) => {
     if (attrParts.length >= MAX_ATTRIBUTES) return
     var type = 5
     var serializedValue

package/src/common/session/session-entity.js

@@ -3,11 +3,11 @@ import { warn } from '../util/console'
 import { stringify } from '../util/stringify'
 import { ee } from '../event-emitter/contextual-ee'
 import { Timer } from '../timer/timer'
-import { isBrowserScope, isIE } from '../constants/runtime'
+import { isBrowserScope } from '../constants/runtime'
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, MODE, PREFIX, SESSION_EVENTS, SESSION_EVENT_TYPES } from './constants'
 import { InteractionTimer } from '../timer/interaction-timer'
-import { wrapEvents } from '../wrap'
-import { getModeledObject } from '../config/state/configurable'
+import { wrapEvents } from '../wrap/wrap-events'
+import { getModeledObject } from '../config/configurable'
 import { handle } from '../event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
 import { FEATURE_NAMES } from '../../loaders/features/features'
@@ -57,7 +57,7 @@ export class SessionEntity {
      * if the event was spawned on the current page or an adjacent page, and the behavior tied
      * to storage events is critical to apply only to cross-tab behavior
      * */
-    if (isBrowserScope && !isIE) {
+    if (isBrowserScope) {
       windowAddEventListener('storage', (event) => {
         if (event.key === this.lookupKey) {
           const obj = typeof event.newValue === 'string' ? JSON.parse(event.newValue) : event.newValue

package/src/common/timing/__mocks__/time-keeper.js

@@ -1,2 +1,6 @@
-export const TimeKeeper = jest.fn(function () {})
-TimeKeeper.ready = true
+export const TimeKeeper = jest.fn(function () {
+  this.ready = true
+  this.convertRelativeTimestamp = jest.fn()
+  this.convertAbsoluteTimestamp = jest.fn()
+  this.correctAbsoluteTimestamp = jest.fn()
+})

package/src/common/timing/time-keeper.js

@@ -1,5 +1,5 @@
 import { originTime } from '../constants/runtime'
-import { getRuntime } from '../config/config'
+import { getRuntime } from '../config/runtime'
 
 const rfc2616Regex = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), ([0-3][0-9]) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([0-9]{4}) ([01][0-9]|2[0-3])(:[0-5][0-9]){2} GMT$/
 
@@ -87,21 +87,31 @@ export class TimeKeeper {
 
   /**
    * Converts a page origin relative time to an absolute timestamp
-   * corrected to NR server time.
+   * using the user's local clock.
    * @param relativeTime {number} The relative time of the event in milliseconds
    * @returns {number} Corrected unix/epoch timestamp
    */
   convertRelativeTimestamp (relativeTime) {
-    return Math.floor(this.#correctedOriginTime + relativeTime)
+    return originTime + relativeTime
   }
 
   /**
-   * Corrects an event timestamp to NR server time.
+   * Converts an absolute timestamp to a relative timestamp using the
+   * user's local clock.
+   * @param timestamp
+   * @returns {number}
+   */
+  convertAbsoluteTimestamp (timestamp) {
+    return timestamp - originTime
+  }
+
+  /**
+   * Corrects an absolute timestamp to NR server time.
    * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
    * @return {number} Corrected unix/epoch timestamp
    */
   correctAbsoluteTimestamp (timestamp) {
-    return Math.floor(timestamp - this.#localTimeDiff)
+    return timestamp - this.#localTimeDiff
   }
 
   /** Process the session entity and use the info to set the main time calculations if present */

package/src/common/url/encode.js

@@ -3,7 +3,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { mapOwn } from '../util/map-own'
 import { stringify } from '../util/stringify'
 
 // Characters that are safe in a qs, but get encoded.
@@ -16,7 +15,7 @@ var charMap = {
   '%3B': ';'
 }
 
-var charList = mapOwn(charMap, function (k) { return k })
+var charList = Object.keys(charMap)
 var safeEncoded = new RegExp(charList.join('|'), 'g')
 
 function real (c) {
@@ -43,7 +42,7 @@ export function obj (payload, maxBytes) {
   var total = 0
   var result = ''
 
-  mapOwn(payload, function (feature, dataArray) {
+  Object.entries(payload || {}).forEach(([feature, dataArray]) => {
     var intermediate = []
     var next
     var i

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

@@ -0,0 +1 @@
+export const warn = jest.fn()

package/src/common/util/__mocks__/obfuscate.js

@@ -1,10 +1,7 @@
 export const Obfuscator = jest.fn(function () {
-  this.sharedContext = {
-    agentIdentifier: 'abcd'
-  }
-
-  this.shouldObfuscate = jest.fn(() => false)
-  this.obfuscateString = jest.fn((input) => input)
+  this.ruleValidationCache = []
+  this.obfuscateString = jest.fn(input => input)
 })
-export const getRules = jest.fn(() => ([]))
-export const validateRules = jest.fn(() => true)
+
+Obfuscator.prototype.validateObfuscationRule = jest.fn(rule => true)
+Obfuscator.prototype.getRuleValidationCache = jest.fn(agentIdentifier => [])

package/src/common/util/console.js

@@ -1,3 +1,5 @@
+/* eslint no-console: ["error", { allow: ["debug"] }] */
+
 /**
  * A helper method to warn to the console with New Relic: decoration
  * @param {string} message The primary message to warn

package/src/common/util/obfuscate.js

@@ -1,67 +1,111 @@
-import { getConfigurationValue } from '../config/config'
-import { SharedContext } from '../context/shared-context'
+import { getConfigurationValue } from '../config/init'
 import { isFileProtocol } from '../url/protocol'
 import { warn } from './console'
 
-var fileProtocolRule = {
-  regex: /^file:\/\/(.*)/,
-  replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
-}
-export class Obfuscator extends SharedContext {
-  shouldObfuscate () {
-    return getRules(this.sharedContext.agentIdentifier).length > 0
-  }
+/**
+ * Represents an obfuscation rule that can be applied to harvested payloads
+ * @typedef {object} ObfuscationRule
+ * @property {string|RegExp} regex The regular expression to match against in the payload
+ * @property {string} [replacement] The string to replace the matched regex with
+ */
 
-  // applies all regex obfuscation rules to provided URL string and returns the result
-  obfuscateString (string) {
-    // if string is empty string, null or not a string, return unmodified
-    if (!string || typeof string !== 'string') return string
+/**
+ * Represents an obfuscation rule validation state
+ * @typedef {object} ObfuscationRuleValidation
+ * @property {ObfuscationRule} rule The original rule validated
+ * @property {boolean} isValid Whether the rule is valid
+ * @property {object} errors Validation errors
+ * @property {boolean} errors.regexMissingDetected Whether the regex is missing
+ * @property {boolean} errors.invalidRegexDetected Whether the regex is invalid
+ * @property {boolean} errors.invalidReplacementDetected Whether the replacement is invalid
+ */
 
-    var rules = getRules(this.sharedContext.agentIdentifier)
-    var obfuscated = string
+export class Obfuscator {
+  /**
+   * @type {ObfuscationRuleValidation[]}
+   */
+  #ruleValidationCache
 
-    // apply every rule to URL string
-    for (var i = 0; i < rules.length; i++) {
-      var regex = rules[i].regex
-      var replacement = rules[i].replacement || '*'
-      obfuscated = obfuscated.replace(regex, replacement)
-    }
-    return obfuscated
+  constructor (agentIdentifier) {
+    this.#ruleValidationCache = Obfuscator.getRuleValidationCache(agentIdentifier)
+    Obfuscator.logObfuscationRuleErrors(this.#ruleValidationCache)
   }
-}
 
-// TO DO: this function should be inside the Obfuscator class since its context relates to agentID
-export function getRules (agentIdentifier) {
-  var rules = []
-  var configRules = getConfigurationValue(agentIdentifier, 'obfuscate') || []
-
-  rules = rules.concat(configRules)
+  get ruleValidationCache () {
+    return this.#ruleValidationCache
+  }
 
-  if (isFileProtocol()) rules.push(fileProtocolRule)
-  // could add additional runtime/environment-specific rules here
+  /**
+   * Applies all valid obfuscation rules to the provided input string
+   * @param {string} input String to obfuscate
+   * @returns {string}
+   */
+  obfuscateString (input) {
+    // if input is not of type string or is an empty string, short-circuit
+    if (typeof input !== 'string' || input.trim().length === 0) return input
 
-  return rules
-}
+    return this.#ruleValidationCache
+      .filter(ruleValidation => ruleValidation.isValid)
+      .reduce((input, ruleValidation) => {
+        const { rule } = ruleValidation
+        return input.replace(rule.regex, rule.replacement || '*')
+      }, input)
+  }
 
-// takes array of rule objects, logs warning and returns false if any portion of rule is invalid
-export function validateRules (rules) {
-  var invalidReplacementDetected = false
-  var invalidRegexDetected = false
-  for (var i = 0; i < rules.length; i++) {
-    if (!('regex' in rules[i])) {
-      warn(12)
-      invalidRegexDetected = true
-    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex instanceof RegExp)) {
-      warn(13)
-      invalidRegexDetected = true
+  /**
+   * Returns an array of obfuscation rules to be applied to harvested payloads
+   * @param {string} agentIdentifier The agent identifier to get rules for
+   * @returns {ObfuscationRuleValidation[]} The array of rules or validation states
+   */
+  static getRuleValidationCache (agentIdentifier) {
+    /**
+     * @type {ObfuscationRule[]}
+     */
+    let rules = getConfigurationValue(agentIdentifier, 'obfuscate') || []
+    if (isFileProtocol()) {
+      rules.push({
+        regex: /^file:\/\/(.*)/,
+        replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
+      })
     }
 
-    var replacement = rules[i].replacement
-    if (replacement && typeof replacement !== 'string') {
-      warn(14)
-      invalidReplacementDetected = true
+    return rules.map(rule => Obfuscator.validateObfuscationRule(rule))
+  }
+
+  /**
+   * Validates an obfuscation rule and provides errors if any are found.
+   * @param {ObfuscationRule} rule The rule to validate
+   * @returns {ObfuscationRuleValidation} The validation state of the rule
+   */
+  static validateObfuscationRule (rule) {
+    const regexMissingDetected = Boolean(rule.regex === undefined)
+    const invalidRegexDetected = Boolean(rule.regex !== undefined && typeof rule.regex !== 'string' && !(rule.regex instanceof RegExp))
+    const invalidReplacementDetected = Boolean(rule.replacement && typeof rule.replacement !== 'string')
+
+    return {
+      rule,
+      isValid: !regexMissingDetected && !invalidRegexDetected && !invalidReplacementDetected,
+      errors: {
+        regexMissingDetected,
+        invalidRegexDetected,
+        invalidReplacementDetected
+      }
     }
   }
 
-  return !invalidReplacementDetected && !invalidRegexDetected
+  /**
+   * Logs any obfuscation rule errors to the console. This is called when an obfuscator
+   * instance is created.
+   * @param {ObfuscationRuleValidation[]} ruleValidationCache The cache of rule validation states
+   */
+  static logObfuscationRuleErrors (ruleValidationCache) {
+    for (const ruleValidation of ruleValidationCache) {
+      const { rule, isValid, errors } = ruleValidation
+      if (isValid) continue
+
+      if (errors.regexMissingDetected) warn(12, rule)
+      else if (errors.invalidRegexDetected) warn(13, rule)
+      if (errors.invalidReplacementDetected) warn(14, rule)
+    }
+  }
 }

package/src/common/util/submit-data.js

@@ -20,7 +20,6 @@ export function getSubmitMethod ({ isFinalHarvest = false } = {}) {
   return isFinalHarvest && isBrowserScope && supportsSendBeacon
     // Use sendBeacon for final harvest
     ? beacon
-    // Only IE does not support sendBeacon for final harvest
     // If not final harvest, or not browserScope, always use xhr post
     : xhr
 }

package/src/common/util/text.js

@@ -0,0 +1,6 @@
+export function toTitleCase (str, regex = /\w*/g) {
+  return str.replace(
+    regex,
+    text => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase()
+  )
+}