@newrelic/browser-agent 1.261.2 → 1.263.0

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

@@ -182,7 +182,7 @@ export class SessionEntity {
 
       return obj
     } catch (e) {
-      warn('Failed to read from storage API', e)
+      warn(10, e)
       // storage is inaccessible
       return {}
     }
@@ -208,7 +208,7 @@ export class SessionEntity {
       return data
     } catch (e) {
       // storage is inaccessible
-      warn('Failed to write to the storage API', e)
+      warn(11, e)
       return null
     }
   }

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

@@ -1,6 +1,8 @@
 import { originTime } from '../constants/runtime'
 import { getRuntime } from '../config/config'
 
+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$/
+
 /**
  * Class used to adjust the timestamp of harvested data to New Relic server time. This
  * is done by tracking the performance timings of the RUM call and applying a calculation
@@ -29,7 +31,7 @@ export class TimeKeeper {
   /**
    * Represents whether the timekeeper is in a state that it can accurately convert
    * timestamps.
-   * @type {number}
+   * @type {boolean}
    */
   #ready = false
 
@@ -46,6 +48,10 @@ export class TimeKeeper {
     return this.#correctedOriginTime
   }
 
+  get localTimeDiff () {
+    return this.#localTimeDiff
+  }
+
   /**
    * Process a rum request to calculate NR server time.
    * @param rumRequest {XMLHttpRequest} The xhr for the rum request
@@ -53,12 +59,16 @@ export class TimeKeeper {
    * @param endTime {number} The end time of the RUM request
    */
   processRumRequest (rumRequest, startTime, endTime) {
-    this.processStoredDiff()
+    this.processStoredDiff() // Check session entity for stored time diff
     if (this.#ready) return // Server time calculated from session entity
+
     const responseDateHeader = rumRequest.getResponseHeader('Date')
     if (!responseDateHeader) {
       throw new Error('Missing date header on rum response.')
     }
+    if (!rfc2616Regex.test(responseDateHeader)) {
+      throw new Error('Date header invalid format.')
+    }
 
     const medianRumOffset = (endTime - startTime) / 2
     const serverOffset = startTime + medianRumOffset
@@ -96,6 +106,8 @@ export class TimeKeeper {
 
   /** Process the session entity and use the info to set the main time calculations if present */
   processStoredDiff () {
+    if (this.#ready) return // Time diff has already been calculated
+
     const storedServerTimeDiff = this.#session?.read()?.serverTimeDiff
     if (typeof storedServerTimeDiff === 'number' && !isNaN(storedServerTimeDiff)) {
       this.#localTimeDiff = storedServerTimeDiff

package/src/common/util/console.js

@@ -4,8 +4,7 @@
  * @param {*} [secondary] Secondary data to include, usually an error or object
  * @returns
  */
-export function warn (message, secondary) {
-  if (typeof console.warn !== 'function') return
-  console.warn(`New Relic: ${message}`)
-  if (secondary) console.warn(secondary)
+export function warn (code, secondary) {
+  if (typeof console.debug !== 'function') return
+  console.debug(`New Relic Warning: https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md#${code}`, secondary)
 }

package/src/common/util/obfuscate.js

@@ -49,16 +49,16 @@ export function validateRules (rules) {
   var invalidRegexDetected = false
   for (var i = 0; i < rules.length; i++) {
     if (!('regex' in rules[i])) {
-      warn('An obfuscation replacement rule was detected missing a "regex" value.')
+      warn(12)
       invalidRegexDetected = true
     } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex instanceof RegExp)) {
-      warn('An obfuscation replacement rule contains a "regex" value with an invalid type (must be a string or RegExp)')
+      warn(13)
       invalidRegexDetected = true
     }
 
     var replacement = rules[i].replacement
     if (replacement && typeof replacement !== 'string') {
-      warn('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)')
+      warn(14)
       invalidReplacementDetected = true
     }
   }

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

@@ -9,6 +9,7 @@
 
 import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
 import { EventContext } from '../event-emitter/event-context'
+import { warn } from '../util/console'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
 
 /**
@@ -20,6 +21,7 @@ import { createWrapperWithEmitter as wfn } from './wrap-function'
  */
 // eslint-disable-next-line
 export function wrapLogger(sharedEE, parent, loggerFn, context) {
+  if (!(typeof parent === 'object' && !!parent && typeof loggerFn === 'string' && !!loggerFn && typeof parent[loggerFn] === 'function')) return warn(29)
   const ee = scopedEE(sharedEE)
   const wrapFn = wfn(ee)
 

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

@@ -56,7 +56,7 @@ export function wrapXhr (sharedEE) {
       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)
+      warn(15, e)
       try {
         ee.emit('internal-error', [e])
       } catch (err) {

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

@@ -6,8 +6,9 @@ import { warn } from '../../../common/util/console'
 import { stringify } from '../../../common/util/stringify'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
-import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOGGING_IGNORED, MAX_PAYLOAD_SIZE } from '../constants'
+import { FEATURE_NAME, LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS, MAX_PAYLOAD_SIZE } from '../constants'
 import { Log } from '../shared/log'
+import { isValidLogLevel } from '../shared/utils'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -43,8 +44,34 @@ export class Aggregate extends AggregateBase {
     })
   }
 
-  handleLog (timestamp, message, attributes, level) {
+  handleLog (timestamp, message, attributes = {}, level = LOG_LEVELS.INFO) {
     if (this.blocked) return
+
+    if (!attributes || typeof attributes !== 'object') attributes = {}
+    if (typeof level === 'string') level = level.toUpperCase()
+    if (!isValidLogLevel(level)) return warn(30, level)
+
+    try {
+      if (typeof message !== 'string') {
+        const stringified = stringify(message)
+        /**
+           * Error instances convert to `{}` when stringified
+           * Symbol converts to '' when stringified
+           * other cases tbd
+           * */
+        if (!!stringified && stringified !== '{}') message = stringified
+        else message = String(message)
+      }
+    } catch (err) {
+      warn(16, message)
+      return
+    }
+    if (typeof message !== 'string' || !message) return warn(32)
+    if (message.length > MAX_PAYLOAD_SIZE) {
+      handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', message.length])
+      return warn(31, message.slice(0, 25) + '...')
+    }
+
     const log = new Log(
       this.#agentRuntime.timeKeeper.convertRelativeTimestamp(timestamp),
       message,
@@ -54,7 +81,7 @@ export class Aggregate extends AggregateBase {
     const logBytes = log.message.length + stringify(log.attributes).length + log.level.length + 10 // timestamp == 10 chars
     if (logBytes > MAX_PAYLOAD_SIZE) {
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['Logging/Harvest/Failed/Seen', logBytes])
-      return warn(LOGGING_IGNORED + '> ' + MAX_PAYLOAD_SIZE + ' bytes', log.message.slice(0, 25) + '...')
+      return warn(31, log.message.slice(0, 25) + '...')
     }
 
     if (this.estimatedBytes + logBytes >= MAX_PAYLOAD_SIZE) {

package/src/features/logging/constants.js

@@ -13,7 +13,3 @@ export const LOGGING_EVENT_EMITTER_CHANNEL = 'log'
 export const FEATURE_NAME = FEATURE_NAMES.logging
 
 export const MAX_PAYLOAD_SIZE = 1000000
-
-export const LOGGING_FAILURE_MESSAGE = 'failed to wrap logger: '
-export const LOGGING_LEVEL_FAILURE_MESSAGE = 'invalid log level: '
-export const LOGGING_IGNORED = 'ignored log: '

package/src/features/logging/shared/utils.js

@@ -1,7 +1,5 @@
 import { handle } from '../../../common/event-emitter/handle'
 import { now } from '../../../common/timing/now'
-import { warn } from '../../../common/util/console'
-import { stringify } from '../../../common/util/stringify'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants'
@@ -13,31 +11,16 @@ import { LOGGING_EVENT_EMITTER_CHANNEL, LOG_LEVELS } from '../constants'
    * @param {enum} level - the log level enum
    */
 export function bufferLog (ee, message, customAttributes = {}, level = LOG_LEVELS.INFO) {
-  try {
-    if (typeof message !== 'string') {
-      const stringified = stringify(message)
-      /**
-       * Error instances convert to `{}` when stringified
-       * Symbol converts to '' when stringified
-       * other cases tbd
-       * */
-      if (!!stringified && stringified !== '{}') message = stringified
-      else message = String(message)
-    }
-  } catch (err) {
-    warn('could not cast log message to string', message)
-    return
-  }
   handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/logging/${level.toLowerCase()}/called`], undefined, FEATURE_NAMES.metrics, ee)
   handle(LOGGING_EVENT_EMITTER_CHANNEL, [now(), message, customAttributes, level], undefined, FEATURE_NAMES.logging, ee)
 }
 
 /**
  * Checks if a supplied log level is acceptable for use in generating a log event
- * @param {string} level
+ * @param {string} level -- must be cast to uppercase before running this test
  * @returns {boolean}
  */
 export function isValidLogLevel (level) {
   if (typeof level !== 'string') return false
-  return Object.values(LOG_LEVELS).some(logLevel => logLevel.toUpperCase() === level.toUpperCase())
+  return Object.values(LOG_LEVELS).some(logLevel => logLevel === level)
 }

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

@@ -96,6 +96,18 @@ export class Aggregate extends AggregateBase {
     // Check if proxy for either chunks or beacon is being used
     if (proxy.assets) this.storeSupportabilityMetrics('Config/AssetsUrl/Changed')
     if (proxy.beacon) this.storeSupportabilityMetrics('Config/BeaconUrl/Changed')
+
+    if (isBrowserScope && window.MutationObserver) {
+      this.storeSupportabilityMetrics('Generic/VideoElement/Added', window.document.querySelectorAll('video').length)
+      const mo = new MutationObserver(records => {
+        records.forEach(record => {
+          record.addedNodes.forEach(addedNode => {
+            if (addedNode instanceof HTMLVideoElement) { this.storeSupportabilityMetrics('Generic/VideoElement/Added', 1) }
+          })
+        })
+      })
+      mo.observe(window.document.body, { childList: true, subtree: true })
+    }
   }
 
   eachSessionChecks () {

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

@@ -1,7 +1,7 @@
 import { globalScope, isBrowserScope, originTime } from '../../../common/constants/runtime'
 import { addPT, addPN } from '../../../common/timing/nav-timing'
 import { stringify } from '../../../common/util/stringify'
-import { getInfo, getRuntime } from '../../../common/config/config'
+import { getInfo, getRuntime, isConfigured } from '../../../common/config/config'
 import { Harvest } from '../../../common/harvest/harvest'
 import * as CONSTANTS from '../constants'
 import { getActivatedFeaturesFlags } from './initialized-features'
@@ -28,6 +28,11 @@ export class Aggregate extends AggregateBase {
     this.firstByteToDomContent = 0 // our "dom processing" duration
     this.timeKeeper = new TimeKeeper(this.agentIdentifier)
 
+    if (!isConfigured(agentIdentifier)) {
+      this.ee.abort()
+      return warn(43)
+    }
+
     if (isBrowserScope) {
       timeToFirstByte.subscribe(({ value, attrs }) => {
         const navEntry = attrs.navigationEntry
@@ -48,7 +53,6 @@ export class Aggregate extends AggregateBase {
     const agentRuntime = getRuntime(this.agentIdentifier)
     const harvester = new Harvest(this)
 
-    if (!info.beacon) return
     if (info.queueTime) this.aggregator.store('measures', 'qt', { value: info.queueTime })
     if (info.applicationTime) this.aggregator.store('measures', 'ap', { value: info.applicationTime })
 
@@ -126,11 +130,24 @@ export class Aggregate extends AggregateBase {
           if (!this.timeKeeper.ready) throw new Error('TimeKeeper not ready')
 
           agentRuntime.timeKeeper = this.timeKeeper
+
+          // Check if the time diff is such that we need to capture a supportability metric
+          if (this.timeKeeper.localTimeDiff >= 12 * 60 * 60 * 1000) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/DiffExceed12Hrs'], undefined, FEATURE_NAMES.metrics, this.ee)
+          } else if (this.timeKeeper.localTimeDiff >= 6 * 60 * 60 * 1000) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/DiffExceed6Hrs'], undefined, FEATURE_NAMES.metrics, this.ee)
+          } else if (this.timeKeeper.localTimeDiff >= 60 * 60 * 1000) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/DiffExceed1Hrs'], undefined, FEATURE_NAMES.metrics, this.ee)
+          }
         } catch (error) {
-          handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, FEATURE_NAMES.metrics, this.ee)
+          if (error?.message?.indexOf('invalid format') > 0) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/InvalidFormat'], undefined, FEATURE_NAMES.metrics, this.ee)
+          } else {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['PVE/NRTime/Calculation/Failed'], undefined, FEATURE_NAMES.metrics, this.ee)
+          }
           drain(this.agentIdentifier, FEATURE_NAMES.metrics, true)
           this.ee.abort()
-          warn('Could not calculate New Relic server time. Agent shutting down.', error)
+          warn(17, error)
           return
         }
 
@@ -141,7 +158,7 @@ export class Aggregate extends AggregateBase {
           this.drain()
         } catch (err) {
           this.ee.abort()
-          warn('RUM call failed. Agent shutting down.', err)
+          warn(18, err)
         }
       }
     })

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

@@ -394,7 +394,7 @@ export class Aggregate extends AggregateBase {
 
   /** Abort the feature, once aborted it will not resume */
   abort (reason = {}, data) {
-    warn(`SR aborted -- ${reason.message}`)
+    warn(33, reason.message)
     handle(SUPPORTABILITY_METRIC_CHANNEL, [`SessionReplay/Abort/${reason.sm}`, data], undefined, FEATURE_NAMES.metrics, this.ee)
     this.blocked = true
     this.mode = MODE.OFF

package/src/features/session_replay/shared/recorder.js

@@ -35,7 +35,7 @@ export class Recorder {
     /** Config to inform to inline stylesheet contents (true default) */
     this.shouldInlineStylesheets = getConfigurationValue(this.parent.agentIdentifier, 'session_replay.inline_stylesheet')
     /** A flag that can be set to false by failing conversions to stop the fetching process */
-    this.shouldFix = this.shouldInlineStylesheets
+    this.shouldFix = this.shouldInlineStylesheets && getConfigurationValue(this.parent.agentIdentifier, 'session_replay.fix_stylesheets')
     /** The method to stop recording. This defaults to a noop, but is overwritten once the recording library is imported and initialized */
     this.stopRecording = () => { /* no-op until set by rrweb initializer */ }
   }

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

@@ -205,6 +205,6 @@ export class Aggregate extends AggregateBase {
     this.blocked = true
     this.mode = MODE.OFF
     this.agentRuntime.session.write({ sessionTraceMode: this.mode })
-    this.scheduler.stopTimer()
+    this.scheduler?.stopTimer()
   }
 }

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

@@ -757,7 +757,7 @@ export class Aggregate extends AggregateBase {
       handle(SUPPORTABILITY_METRIC_CHANNEL, [`Spa/Interaction/${smCategory}/Duration/Ms`, Math.max((interaction.root?.end || 0) - (interaction.root?.start || 0), 0)], undefined, FEATURE_NAMES.metrics, baseEE)
 
       scheduler?.scheduleHarvest(0)
-      if (!scheduler) warn('SPA scheduler is not initialized. Saved interaction is not sent!')
+      if (!scheduler) warn(19)
     }
 
     function isEnabled () {

package/src/features/utils/aggregate-base.js

@@ -49,7 +49,8 @@ export class AggregateBase extends FeatureBase {
   checkConfiguration () {
     // NOTE: This check has to happen at aggregator load time
     if (!isConfigured(this.agentIdentifier)) {
-      let jsAttributes = { ...gosCDN().info?.jsAttributes }
+      const cdn = gosCDN()
+      let jsAttributes = { ...cdn.info?.jsAttributes }
       try {
         jsAttributes = {
           ...jsAttributes,
@@ -59,9 +60,9 @@ export class AggregateBase extends FeatureBase {
         // do nothing
       }
       configure({ agentIdentifier: this.agentIdentifier }, {
-        ...gosCDN(),
+        ...cdn,
         info: {
-          ...gosCDN().info,
+          ...cdn.info,
           jsAttributes
         },
         runtime: getRuntime(this.agentIdentifier)

package/src/features/utils/instrument-base.js

@@ -85,7 +85,7 @@ export class InstrumentBase extends FeatureBase {
           session = setupAgentSession(this.agentIdentifier)
         }
       } catch (e) {
-        warn('A problem occurred when starting up session manager. This page will not start or extend any session.', e)
+        warn(20, e)
         this.ee.emit('internal-error', [e])
         if (this.featureName === FEATURE_NAMES.sessionReplay) this.abortHandler?.() // SR should stop recording if session DNE
       }
@@ -105,7 +105,7 @@ export class InstrumentBase extends FeatureBase {
         this.featAggregate = new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument)
         loadedSuccessfully(true)
       } catch (e) {
-        warn(`Downloading and initializing ${this.featureName} failed...`, e)
+        warn(34, e)
         this.abortHandler?.() // undo any important alterations made to the page
         // not supported yet but nice to do: "abort" this agent's EE for this feature specifically
         drain(this.agentIdentifier, this.featureName, true)

package/src/loaders/agent-base.js

@@ -25,7 +25,7 @@ export class AgentBase {
    * @param  {...any} args
    */
   #callMethod (methodName, ...args) {
-    if (typeof this.api?.[methodName] !== 'function') warn(`Call to agent api ${methodName} failed. The API is not currently initialized.`)
+    if (typeof this.api?.[methodName] !== 'function') warn(35, methodName)
     else return this.api[methodName](...args)
   }
 

package/src/loaders/agent.js

@@ -13,7 +13,6 @@ import { Instrument as PageViewEvent } from '../features/page_view_event/instrum
 import { Aggregator } from '../common/aggregate/aggregator'
 import { gosNREUM, setNREUMInitializedAgent } from '../common/window/nreum'
 import { warn } from '../common/util/console'
-import { stringify } from '../common/util/stringify'
 import { globalScope } from '../common/constants/runtime'
 
 /**
@@ -31,7 +30,7 @@ export class Agent extends AgentBase {
     if (!globalScope) {
       // We could not determine the runtime environment. Short-circuite the agent here
       // to avoid possible exceptions later that may cause issues with customer's application.
-      warn('Failed to initialize the agent. Could not determine the runtime environment.')
+      warn(21)
       return
     }
 
@@ -74,12 +73,12 @@ export class Agent extends AgentBase {
 
         const dependencies = getFeatureDependencyNames(InstrumentCtor.featureName)
         const hasAllDeps = dependencies.every(featName => featName in this.features) // any other feature(s) this depends on should've been initialized on prior iterations by priority order
-        if (!hasAllDeps) warn(`${InstrumentCtor.featureName} is enabled but one or more dependent features has not been initialized (${stringify(dependencies)}). This may cause unintended consequences or missing data...`)
+        if (!hasAllDeps) warn(36, InstrumentCtor.featureName)
 
         this.features[InstrumentCtor.featureName] = new InstrumentCtor(this.agentIdentifier, this.sharedAggregator)
       })
     } catch (err) {
-      warn('Failed to initialize all enabled instrument classes (agent aborted) -', err)
+      warn(22, err)
       for (const featName in this.features) { // this.features hold only features that have been instantiated
         this.features[featName].abortHandler?.()
       }

package/src/loaders/api/api.js

@@ -16,8 +16,8 @@ import { apiMethods, asyncApiMethods } from './api-methods'
 import { SR_EVENT_EMITTER_TYPES } from '../../features/session_replay/constants'
 import { now } from '../../common/timing/now'
 import { MODE } from '../../common/session/constants'
-import { LOGGING_FAILURE_MESSAGE, LOGGING_IGNORED, LOGGING_LEVEL_FAILURE_MESSAGE, LOG_LEVELS, MAX_PAYLOAD_SIZE } from '../../features/logging/constants'
-import { bufferLog, isValidLogLevel } from '../../features/logging/shared/utils'
+import { LOG_LEVELS } from '../../features/logging/constants'
+import { bufferLog } from '../../features/logging/shared/utils'
 import { wrapLogger } from '../../common/wrap/wrap-logger'
 
 export function setTopLevelCallers () {
@@ -29,7 +29,9 @@ export function setTopLevelCallers () {
   function caller (fnName, ...args) {
     let returnVals = []
     Object.values(nr.initializedAgents).forEach(val => {
-      if (val.exposed && val.api[fnName]) {
+      if (!val || !val.api) {
+        warn(38, fnName)
+      } else if (val.exposed && val.api[fnName]) {
         returnVals.push(val.api[fnName](...args))
       }
     })
@@ -55,18 +57,13 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
   var spaPrefix = prefix + 'ixn-'
 
   apiInterface.log = function (message, { customAttributes = {}, level = LOG_LEVELS.INFO } = {}) {
-    if (!customAttributes || typeof customAttributes !== 'object') customAttributes = {}
-    if (typeof message !== 'string' || !message) return warn(LOGGING_IGNORED + 'invalid message')
-    if (!isValidLogLevel(level)) return warn(LOGGING_LEVEL_FAILURE_MESSAGE + level, LOG_LEVELS)
-    if (message.length > MAX_PAYLOAD_SIZE) return warn(LOGGING_IGNORED + '> ' + MAX_PAYLOAD_SIZE + ' bytes: ', message.slice(0, 25) + '...')
-    bufferLog(instanceEE, message, customAttributes, level.toUpperCase())
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/log/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
+    bufferLog(instanceEE, message, customAttributes, level)
   }
 
   apiInterface.wrapLogger = (parent, functionName, { customAttributes = {}, level = LOG_LEVELS.INFO } = {}) => {
-    if (!customAttributes || typeof customAttributes !== 'object') customAttributes = {}
-    if (!(typeof parent === 'object' && !!parent && typeof functionName === 'string' && !!functionName && typeof parent[functionName] === 'function' && typeof customAttributes === 'object')) return warn(LOGGING_FAILURE_MESSAGE + 'invalid argument(s)')
-    if (!isValidLogLevel(level)) return warn(LOGGING_FAILURE_MESSAGE + LOGGING_LEVEL_FAILURE_MESSAGE + level, LOG_LEVELS)
-    wrapLogger(instanceEE, parent, functionName, { customAttributes, level: level.toUpperCase() })
+    handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/wrapLogger/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
+    wrapLogger(instanceEE, parent, functionName, { customAttributes, level })
   }
 
   // Setup stub functions that queue calls for later processing.
@@ -100,11 +97,11 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
   }
   apiInterface.setCustomAttribute = function (name, value, persistAttribute = false) {
     if (typeof name !== 'string') {
-      warn(`Failed to execute setCustomAttribute.\nName must be a string type, but a type of <${typeof name}> was provided.`)
+      warn(39, typeof name)
       return
     }
     if (!(['string', 'number', 'boolean'].includes(typeof value) || value === null)) {
-      warn(`Failed to execute setCustomAttribute.\nNon-null value must be a string, number or boolean type, but a type of <${typeof value}> was provided.`)
+      warn(40, typeof value)
       return
     }
     return appendJsAttribute(name, value, 'setCustomAttribute', persistAttribute)
@@ -116,7 +113,7 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
    */
   apiInterface.setUserId = function (value) {
     if (!(typeof value === 'string' || value === null)) {
-      warn(`Failed to execute setUserId.\nNon-null value must be a string type, but a type of <${typeof value}> was provided.`)
+      warn(41, typeof value)
       return
     }
     return appendJsAttribute('enduser.id', value, 'setUserId', true)
@@ -129,7 +126,7 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
    */
   apiInterface.setApplicationVersion = function (value) {
     if (!(typeof value === 'string' || value === null)) {
-      warn(`Failed to execute setApplicationVersion. Expected <String | null>, but got <${typeof value}>.`)
+      warn(42, typeof value)
       return
     }
     return appendJsAttribute('application.version', value, 'setApplicationVersion', false)
@@ -140,7 +137,7 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
       handle(SUPPORTABILITY_METRIC_CHANNEL, ['API/start/called'], undefined, FEATURE_NAMES.metrics, instanceEE)
       instanceEE.emit('manual-start-all')
     } catch (err) {
-      warn('An unexpected issue occurred', err)
+      warn(23, err)
     }
   }
 
@@ -215,7 +212,7 @@ export function setAPI (agentIdentifier, forceDrain, runSoftNavOverSpa = false)
       setAPI(agentIdentifier)
       drain(agentIdentifier, 'api')
     }).catch((err) => {
-      warn('Downloading runtime APIs failed...', err)
+      warn(27, err)
       instanceEE.abort()
     })
   }

package/src/loaders/micro-agent.js

@@ -61,11 +61,11 @@ export class MicroAgent extends AgentBase {
       if (features === undefined) features = featNames
       else {
         features = Array.isArray(features) && features.length ? features : [features]
-        if (features.some(f => !featNames.includes(f))) return warn(`Invalid feature name supplied. Acceptable feature names are: ${featNames}`)
+        if (features.some(f => !featNames.includes(f))) return warn(37, featNames)
         if (!features.includes(FEATURE_NAMES.pageViewEvent)) features.push(FEATURE_NAMES.pageViewEvent)
       }
     } catch (err) {
-      warn('An unexpected issue occurred', err)
+      warn(23, err)
     }
 
     try {
@@ -75,7 +75,7 @@ export class MicroAgent extends AgentBase {
         // a biproduct of doing this is that the "session manager" is automatically handled through importing this feature
         this.features.page_view_event = new PVE(this.agentIdentifier, this.sharedAggregator)
       } catch (err) {
-        warn('Something prevented the agent from instrumenting.', err)
+        warn(24, err)
       }
 
       onWindowLoad(() => {
@@ -87,13 +87,13 @@ export class MicroAgent extends AgentBase {
             }).then(({ Aggregate }) => {
               this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator)
             }).catch(err =>
-              warn('Something prevented the agent from being downloaded.', err))
+              warn(25, err))
           }
         })
       })
       return true
     } catch (err) {
-      warn('Failed to initialize instrument classes.', err)
+      warn(26, err)
       return false
     }
   }