@newrelic/browser-agent 0.0.9 → 0.1.230

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

@@ -0,0 +1,310 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { canonicalFunctionName } from './canonical-function-name'
+import { cleanURL } from '../../../common/url/clean-url'
+import { computeStackTrace } from './compute-stack-trace'
+import { stringHashCode } from './string-hash-code'
+import { truncateSize } from './format-stack-trace'
+
+import { registerHandler as register } from '../../../common/event-emitter/register-handler'
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
+import { stringify } from '../../../common/util/stringify'
+import { handle } from '../../../common/event-emitter/handle'
+import { mapOwn } from '../../../common/util/map-own'
+import { getInfo, getConfigurationValue, getRuntime } from '../../../common/config/config'
+import { now } from '../../../common/timing/now'
+import { globalScope } from '../../../common/util/global-scope'
+
+import { AggregateBase } from '../../utils/aggregate-base'
+import { FEATURE_NAME } from '../constants'
+import { drain } from '../../../common/drain/drain'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
+
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME
+  constructor (agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME)
+
+    this.stackReported = {}
+    this.pageviewReported = {}
+    this.errorCache = {}
+    this.currentBody
+    this.errorOnPage = false
+
+    // this will need to change to match whatever ee we use in the instrument
+    this.ee.on('interactionSaved', (interaction) => this.onInteractionSaved(interaction))
+
+    // this will need to change to match whatever ee we use in the instrument
+    this.ee.on('interactionDiscarded', (interaction) => this.onInteractionDiscarded(interaction))
+
+    register('err', (...args) => this.storeError(...args), this.featureName, this.ee)
+    register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee)
+
+    const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10
+
+    const scheduler = new HarvestScheduler('jserrors', { onFinished: (...args) => this.onHarvestFinished(...args) }, this)
+    scheduler.harvest.on('jserrors', (...args) => this.onHarvestStarted(...args))
+
+    // Don't start harvesting until "drain" for this feat has been called (which currently requires RUM response).
+    this.ee.on(`drain-${this.featureName}`, () => {
+      if (!this.blocked) scheduler.startTimer(harvestTimeSeconds) // and only if ingest will accept jserror payloads
+    })
+
+    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
+    register('block-err', () => {
+      this.blocked = true
+      scheduler.stopTimer(true)
+    }, this.featureName, this.ee)
+
+    drain(this.agentIdentifier, this.featureName)
+  }
+
+  onHarvestStarted (options) {
+    // this gets rid of dependency in AJAX module
+    var body = this.aggregator.take(['err', 'ierr', 'xhr'])
+
+    if (options.retry) {
+      this.currentBody = body
+    }
+
+    var payload = { body: body, qs: {} }
+    var releaseIds = stringify(getRuntime(this.agentIdentifier).releaseIds)
+
+    if (releaseIds !== '{}') {
+      payload.qs.ri = releaseIds
+    }
+
+    if (body && body.err && body.err.length && !this.errorOnPage) {
+      payload.qs.pve = '1'
+      this.errorOnPage = true
+    }
+    return payload
+  }
+
+  onHarvestFinished (result) {
+    if (result.retry && this.currentBody) {
+      mapOwn(this.currentBody, (key, value) => {
+        for (var i = 0; i < value.length; i++) {
+          var bucket = value[i]
+          var name = this.getBucketName(bucket.params, bucket.custom)
+          this.aggregator.merge(key, name, bucket.metrics, bucket.params, bucket.custom)
+        }
+      })
+      this.currentBody = null
+    }
+  }
+
+  nameHash (params) {
+    return stringHashCode(`${params.exceptionClass}_${params.message}_${params.stack_trace || params.browser_stack_hash}`)
+  }
+
+  getBucketName (params, customParams) {
+    return this.nameHash(params) + ':' + stringHashCode(stringify(customParams))
+  }
+
+  canonicalizeURL (url, cleanedOrigin) {
+    if (typeof url !== 'string') return ''
+
+    var cleanedURL = cleanURL(url)
+    if (cleanedURL === cleanedOrigin) {
+      return '<inline>'
+    } else {
+      return cleanedURL
+    }
+  }
+
+  buildCanonicalStackString (stackInfo, cleanedOrigin) {
+    var canonicalStack = ''
+
+    for (var i = 0; i < stackInfo.frames.length; i++) {
+      var frame = stackInfo.frames[i]
+      var func = canonicalFunctionName(frame.func)
+
+      if (canonicalStack) canonicalStack += '\n'
+      if (func) canonicalStack += func + '@'
+      if (typeof frame.url === 'string') canonicalStack += frame.url
+      if (frame.line) canonicalStack += ':' + frame.line
+    }
+
+    return canonicalStack
+  }
+
+  // Strip query parameters and fragments from the stackString property of the
+  // given stackInfo, along with the 'url' properties of each frame in
+  // stackInfo.frames.
+  //
+  // Any URLs that are equivalent to the cleaned version of the origin will also
+  // be replaced with the string '<inline>'.
+  //
+  canonicalizeStackURLs (stackInfo) {
+    // Currently, loader.origin might contain a fragment, but we don't want to use it
+    // for comparing with frame URLs.
+    var cleanedOrigin = cleanURL(getRuntime(this.agentIdentifier).origin)
+
+    for (var i = 0; i < stackInfo.frames.length; i++) {
+      var frame = stackInfo.frames[i]
+      var originalURL = frame.url
+      var cleanedURL = this.canonicalizeURL(originalURL, cleanedOrigin)
+      if (cleanedURL && cleanedURL !== frame.url) {
+        frame.url = cleanedURL
+        stackInfo.stackString = stackInfo.stackString.split(originalURL).join(cleanedURL)
+      }
+    }
+
+    return stackInfo
+  }
+
+  storeError (err, time, internal, customAttributes) {
+    // are we in an interaction
+    time = time || now()
+    const agentRuntime = getRuntime(this.agentIdentifier)
+    let filterOutput
+
+    if (!internal && agentRuntime.onerror) {
+      filterOutput = agentRuntime.onerror(err)
+      if (filterOutput && !(typeof filterOutput.group === 'string' && filterOutput.group.length)) {
+        // All truthy values mean don't report (store) the error, per backwards-compatible usage,
+        // - EXCEPT if a fingerprinting label is returned, via an object with key of 'group' and value of non-empty string
+        return
+      }
+      // Again as with previous usage, all falsey values would include the error.
+    }
+
+    var stackInfo = this.canonicalizeStackURLs(computeStackTrace(err))
+    var canonicalStack = this.buildCanonicalStackString(stackInfo)
+
+    const params = {
+      stackHash: stringHashCode(canonicalStack),
+      exceptionClass: stackInfo.name,
+      request_uri: globalScope?.location.pathname
+    }
+    if (stackInfo.message) params.message = '' + stackInfo.message
+    // Notice if filterOutput isn't false|undefined OR our specified object, this func would've returned already (so it's unnecessary to req-check group).
+    // Do not modify the name ('errorGroup') of params without DEM approval!
+    if (filterOutput?.group) params.errorGroup = filterOutput.group
+
+    /**
+     * The bucketHash is different from the params.stackHash because the params.stackHash is based on the canonicalized
+     * stack trace and is used downstream in NR1 to attempt to group the same errors across different browsers. However,
+     * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
+     * bucketing and ultimately resulting in the loss of data in NR1.
+     */
+    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`)
+
+    if (!this.stackReported[bucketHash]) {
+      this.stackReported[bucketHash] = true
+      params.stack_trace = truncateSize(stackInfo.stackString)
+    } else {
+      params.browser_stack_hash = stringHashCode(stackInfo.stackString)
+    }
+    params.releaseIds = stringify(agentRuntime.releaseIds)
+
+    // When debugging stack canonicalization/hashing, uncomment these lines for
+    // more output in the test logs
+    // params.origStack = err.stack
+    // params.canonicalStack = canonicalStack
+
+    if (!this.pageviewReported[bucketHash]) {
+      params.pageview = 1
+      this.pageviewReported[bucketHash] = true
+    }
+
+    var type = internal ? 'ierr' : 'err'
+    var newMetrics = { time: time }
+
+    // stn and spa aggregators listen to this event - stn sends the error in its payload,
+    // and spa annotates the error with interaction info
+    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    handle('errorAgg', [type, bucketHash, params, newMetrics], undefined, FEATURE_NAMES.spa, this.ee)
+
+    // still send EE events for other features such as above, but stop this one from aggregating internal data
+    if (this.blocked) return
+    if (params._interactionId != null) {
+      // hold on to the error until the interaction finishes
+      this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || []
+      this.errorCache[params._interactionId].push([type, bucketHash, params, newMetrics, att, customAttributes])
+    } else {
+      // store custom attributes
+      var customParams = {}
+      var att = getInfo(this.agentIdentifier).jsAttributes
+      mapOwn(att, setCustom)
+      if (customAttributes) {
+        mapOwn(customAttributes, setCustom)
+      }
+
+      var jsAttributesHash = stringHashCode(stringify(customParams))
+      var aggregateHash = bucketHash + ':' + jsAttributesHash
+      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams)
+    }
+
+    function setCustom (key, val) {
+      customParams[key] = (val && typeof val === 'object' ? stringify(val) : val)
+    }
+  }
+
+  onInteractionSaved (interaction) {
+    if (!this.errorCache[interaction.id] || this.blocked) return
+
+    this.errorCache[interaction.id].forEach((item) => {
+      var customParams = {}
+      var globalCustomParams = item[4]
+      var localCustomParams = item[5]
+
+      mapOwn(globalCustomParams, setCustom)
+      mapOwn(interaction.root.attrs.custom, setCustom)
+      mapOwn(localCustomParams, setCustom)
+
+      var params = item[2]
+      params.browserInteractionId = interaction.root.attrs.id
+      delete params._interactionId
+
+      if (params._interactionNodeId) {
+        params.parentNodeId = params._interactionNodeId.toString()
+        delete params._interactionNodeId
+      }
+
+      var hash = item[1] + interaction.root.attrs.id
+      var jsAttributesHash = stringHashCode(stringify(customParams))
+      var aggregateHash = hash + ':' + jsAttributesHash
+
+      this.aggregator.store(item[0], aggregateHash, params, item[3], customParams)
+
+      function setCustom (key, val) {
+        customParams[key] = (val && typeof val === 'object' ? stringify(val) : val)
+      }
+    })
+    delete this.errorCache[interaction.id]
+  }
+
+  onInteractionDiscarded (interaction) {
+    if (!this.errorCache || !this.errorCache[interaction.id] || this.blocked) return
+
+    this.errorCache[interaction.id].forEach((item) => {
+      var customParams = {}
+      var globalCustomParams = item[4]
+      var localCustomParams = item[5]
+
+      mapOwn(globalCustomParams, setCustom)
+      mapOwn(interaction.root.attrs.custom, setCustom)
+      mapOwn(localCustomParams, setCustom)
+
+      var params = item[2]
+      delete params._interactionId
+      delete params._interactionNodeId
+
+      var hash = item[1]
+      var jsAttributesHash = stringHashCode(stringify(customParams))
+      var aggregateHash = hash + ':' + jsAttributesHash
+
+      this.aggregator.store(item[0], aggregateHash, item[2], item[3], customParams)
+
+      function setCustom (key, val) {
+        customParams[key] = (val && typeof val === 'object' ? stringify(val) : val)
+      }
+    })
+    delete this.errorCache[interaction.id]
+  }
+}

package/src/features/jserrors/aggregate/string-hash-code.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function stringHashCode (string) {
+  var hash = 0
+  var charVal
+
+  if (!string || !string.length) return hash
+  for (var i = 0; i < string.length; i++) {
+    charVal = string.charCodeAt(i)
+    hash = ((hash << 5) - hash) + charVal
+    hash = hash | 0 // Convert to 32bit integer
+  }
+  return hash
+}

package/src/features/jserrors/aggregate/string-hash-code.test.js

@@ -0,0 +1,12 @@
+import { stringHashCode } from './string-hash-code'
+
+test.each([
+  { input: undefined, expected: 0, title: 'Return 0 for undefined input' },
+  { input: null, expected: 0, title: 'Return 0 for null input' },
+  { input: '', expected: 0, title: 'Return 0 for empty string input' },
+  { input: 'lksjdflksjdf', expected: 32668720, title: 'Return valid hash of string' }
+])('$title', ({ input, expected }) => {
+  const result = stringHashCode(input)
+
+  expect(result).toEqual(expected)
+})

package/src/features/jserrors/constants.js

@@ -0,0 +1,4 @@
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+export const FEATURE_NAME = FEATURE_NAMES.jserrors
+export const NR_ERR_PROP = 'nr@seenError'

package/src/features/jserrors/index.js

@@ -0,0 +1 @@
+export { Instrument as JSErrors } from './instrument/index'

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ee } from '../../../common/event-emitter/contextual-ee'
+import { mapOwn } from '../../../common/util/map-own'
+
+var flags = {}
+var flagArr
+
+try {
+  flagArr = localStorage.getItem('__nr_flags').split(',')
+  if (console && typeof console.log === 'function') {
+    flags.console = true
+    if (flagArr.indexOf('dev') !== -1) flags.dev = true
+    if (flagArr.indexOf('nr_dev') !== -1) flags.nrDev = true
+  }
+} catch (err) {
+  // no op
+}
+
+if (flags.nrDev) ee.on('internal-error', function (err) { log(err.stack) })
+if (flags.dev) ee.on('fn-err', function (args, origThis, err) { log(err.stack) })
+if (flags.dev) {
+  log('NR AGENT IN DEVELOPMENT MODE')
+  log('flags: ' + mapOwn(flags, function (key, val) { return key }).join(', '))
+}
+
+function log (message) {
+  try {
+    if (flags.console) log(message)
+  } catch (err) {
+    // no op
+  }
+}

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

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { handle } from '../../../common/event-emitter/handle'
+import { now } from '../../../common/timing/now'
+import { getOrSet } from '../../../common/util/get-or-set'
+import { wrapRaf, wrapTimer, wrapEvents, wrapXhr } from '../../../common/wrap'
+import slice from 'lodash._slice'
+import './debug'
+import { InstrumentBase } from '../../utils/instrument-base'
+import { FEATURE_NAME, NR_ERR_PROP } from '../constants'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
+import { globalScope } from '../../../common/util/global-scope'
+import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
+import { getRuntime } from '../../../common/config/config'
+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)
+    // 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) {}
+
+    const thisInstrument = this
+    thisInstrument.ee.on('fn-start', function (args, obj, methodName) {
+      if (thisInstrument.abortHandler) thisInstrument.skipNext += 1
+    })
+    thisInstrument.ee.on('fn-err', function (args, obj, err) {
+      if (thisInstrument.abortHandler && !err[NR_ERR_PROP]) {
+        getOrSet(err, NR_ERR_PROP, function getVal () {
+          return true
+        })
+        this.thrown = true
+        notice(err, undefined, thisInstrument.ee)
+      }
+    })
+    thisInstrument.ee.on('fn-end', function () {
+      if (!thisInstrument.abortHandler) return
+      if (!this.thrown && thisInstrument.skipNext > 0) thisInstrument.skipNext -= 1
+    })
+    thisInstrument.ee.on('internal-error', function (e) {
+      handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee)
+    })
+
+    // Replace global error handler with our own.
+    this.origOnerror = globalScope.onerror
+    globalScope.onerror = this.onerrorHandler.bind(this)
+
+    globalScope.addEventListener('unhandledrejection', (e) => {
+      /** rejections can contain data of any type -- this is an effort to keep the message human readable */
+      const err = castReasonToError(e.reason)
+      handle('err', [err, now(), false, { unhandledPromiseRejection: 1 }], undefined, FEATURE_NAMES.jserrors, this.ee)
+    }, eventListenerOpts(false, this.removeOnAbort?.signal))
+
+    wrapRaf(this.ee)
+    wrapTimer(this.ee)
+    wrapEvents(this.ee)
+    if (getRuntime(agentIdentifier).xhrWrappable) wrapXhr(this.ee)
+
+    this.abortHandler = this.#abort // we also use this as a flag to denote that the feature is active or on and handling errors
+    this.importAggregator()
+  }
+
+  /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
+  #abort () {
+    this.removeOnAbort?.abort()
+    this.abortHandler = undefined // weakly allow this abort op to run only once
+  }
+
+  /**
+   * FF and Android browsers do not provide error info to the 'error' event callback,
+   * so we must use window.onerror
+   * @param {string} message
+   * @param {string} filename
+   * @param {number} lineno
+   * @param {number} column
+   * @param {Error | *} errorObj
+   * @returns
+   */
+  onerrorHandler (message, filename, lineno, column, errorObj) {
+    if (typeof this.origOnerror === 'function') this.origOnerror(...arguments)
+
+    try {
+      if (this.skipNext) this.skipNext -= 1
+      else notice(errorObj || new UncaughtException(message, filename, lineno), true, this.ee)
+    } catch (e) {
+      try {
+        handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee)
+      } catch (err) {
+        // do nothing
+      }
+    }
+    return false // maintain default behavior of the error event of Window
+  }
+}
+
+/**
+ *
+ * @param {string} message
+ * @param {string} filename
+ * @param {number} lineno
+ */
+function UncaughtException (message, filename, lineno) {
+  this.message = message || 'Uncaught error with no additional information'
+  this.sourceURL = filename
+  this.line = lineno
+}
+
+/**
+ * Adds a timestamp and emits the 'err' event, which the error aggregator listens for
+ * @param {Error} err
+ * @param {boolean} doNotStamp
+ * @param {ContextualEE} ee
+ */
+function notice (err, doNotStamp, ee) {
+  // by default add timestamp, unless specifically told not to
+  // this is to preserve existing behavior
+  var time = (!doNotStamp) ? now() : null
+  handle('err', [err, time], undefined, FEATURE_NAMES.jserrors, ee)
+}
+
+/**
+ * Attempts to cast an unhandledPromiseRejection reason (reject(...)) to an Error object
+ * @param {*} reason - The reason property from an unhandled promise rejection
+ * @returns {Error} - An Error object with the message as the casted reason
+ */
+function castReasonToError (reason) {
+  let prefix = 'Unhandled Promise Rejection: '
+  if (reason instanceof Error) {
+    try {
+      reason.message = prefix + reason.message
+      return reason
+    } catch (e) {
+      return reason
+    }
+  }
+  if (typeof reason === 'undefined') return new Error(prefix)
+  try {
+    return new Error(prefix + stringify(reason))
+  } catch (err) {
+    return new Error(prefix)
+  }
+}

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

@@ -0,0 +1,134 @@
+import { getRuntime } from '../../../common/config/config'
+import { registerHandler } from '../../../common/event-emitter/register-handler'
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
+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 { getRules, validateRules } from '../../../common/util/obfuscate'
+import { VERSION } from '../../../common/constants/environment-variables'
+import { onDOMContentLoaded } from '../../../common/window/load'
+import { windowAddEventListener } from '../../../common/event-listener/event-listener-opts'
+import { isBrowserScope } from '../../../common/util/global-scope'
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME
+  constructor (agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME)
+    let scheduler
+
+    // If RUM-call's response determines that customer lacks entitlements for the /jserror ingest endpoint, don't harvest at all.
+    registerHandler('block-err', () => {
+      this.blocked = true
+      if (scheduler) scheduler.aborted = true // RUM response may or may not have happened already before scheduler initialization below
+    }, this.featureName, this.ee)
+
+    // Allow features external to the metrics feature to capture SMs and CMs through the event emitter
+    registerHandler(SUPPORTABILITY_METRIC_CHANNEL, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee)
+    registerHandler(CUSTOM_METRIC_CHANNEL, this.storeEventMetrics.bind(this), this.featureName, this.ee)
+
+    this.singleChecks() // checks that are run only one time, at script load
+    this.eachSessionChecks() // the start of every time user engages with page
+
+    // *cli, Mar 23 - Per NR-94597, this feature should only harvest ONCE at the (potential) EoL time of the page.
+    scheduler = new HarvestScheduler('jserrors', { onUnload: () => this.unload() }, this)
+    scheduler.harvest.on('jserrors', () => ({ body: this.aggregator.take(['cm', 'sm']) }))
+
+    drain(this.agentIdentifier, this.featureName) // regardless if this is blocked or not, drain is needed to unblock other features from harvesting (counteract registerDrain)
+  }
+
+  storeSupportabilityMetrics (name, value) {
+    if (this.blocked) return
+    const type = SUPPORTABILITY_METRIC
+    const params = { name }
+    this.aggregator.storeMetric(type, name, params, value)
+  }
+
+  storeEventMetrics (name, metrics) {
+    if (this.blocked) return
+    const type = CUSTOM_METRIC
+    const params = { name }
+    this.aggregator.store(type, name, params, metrics)
+  }
+
+  singleChecks () {
+    // report generic info about the agent itself
+    // note the browser agent version
+    this.storeSupportabilityMetrics(`Generic/Version/${VERSION}/Detected`)
+    // report loaderType
+    const { distMethod, loaderType } = getRuntime(this.agentIdentifier)
+    if (loaderType) this.storeSupportabilityMetrics(`Generic/LoaderType/${loaderType}/Detected`)
+    if (distMethod) this.storeSupportabilityMetrics(`Generic/DistMethod/${distMethod}/Detected`)
+
+    // frameworks on page
+    if (isBrowserScope) {
+      onDOMContentLoaded(() => {
+        getFrameworks().forEach(framework => {
+          this.storeSupportabilityMetrics('Framework/' + framework + '/Detected')
+        })
+      })
+    }
+
+    // file protocol detection
+    if (protocol.isFileProtocol()) {
+      this.storeSupportabilityMetrics('Generic/FileProtocol/Detected')
+      protocol.supportabilityMetricSent = true
+    }
+
+    // obfuscation rules detection
+    const rules = getRules(this.agentIdentifier)
+    if (rules.length > 0) this.storeSupportabilityMetrics('Generic/Obfuscate/Detected')
+    if (rules.length > 0 && !validateRules(rules)) this.storeSupportabilityMetrics('Generic/Obfuscate/Invalid')
+  }
+
+  eachSessionChecks () {
+    if (!isBrowserScope) return
+
+    // [Temporary] Report restores from BFCache to NR1 while feature flag is in place in lieu of sending pageshow events.
+    windowAddEventListener('pageshow', (evt) => {
+      if (evt.persisted) { this.storeSupportabilityMetrics('Generic/BFCache/PageRestored') }
+      return
+    })
+  }
+
+  unload () {
+    // Page Resources detection for estimations with resources feature work
+    // TODO - these SMs are to be removed when we implement the actual resources feature
+    try {
+      if (this.resourcesSent) return
+      const agentRuntime = getRuntime(this.agentIdentifier)
+      // make sure this only gets sent once
+      this.resourcesSent = true
+      // differentiate between internal+external and ajax+non-ajax
+      const ajaxResources = ['beacon', 'fetch', 'xmlhttprequest']
+      const internalUrls = ['nr-data.net', 'newrelic.com', 'nr-local.net', 'localhost']
+      function isInternal (x) { return internalUrls.some(y => x.name.indexOf(y) >= 0) }
+      function isAjax (x) { return ajaxResources.includes(x.initiatorType) }
+      const allResources = performance?.getEntriesByType('resource') || []
+      allResources.forEach((entry) => {
+        if (isInternal(entry)) {
+          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/Internal')
+          else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/Internal')
+        } else {
+          if (isAjax(entry)) this.storeSupportabilityMetrics('Generic/Resources/Ajax/External')
+          else this.storeSupportabilityMetrics('Generic/Resources/Non-Ajax/External')
+        }
+      })
+
+      // Capture per-agent bytes sent for each endpoint (see harvest) and RUM call (see page_view_event aggregator).
+      Object.keys(agentRuntime.bytesSent).forEach(endpoint => {
+        this.storeSupportabilityMetrics(
+          `PageSession/Endpoint/${endpoint.charAt(0).toUpperCase() + endpoint.slice(1)}/BytesSent`,
+          agentRuntime.bytesSent[endpoint]
+        )
+      })
+
+      // Capture metrics for session trace if active (`ptid` is set when returned by replay ingest).
+      if (agentRuntime.ptid) {
+        this.storeSupportabilityMetrics('PageSession/Feature/SessionTrace/DurationMs', Math.round(performance.now()))
+      }
+    } catch (e) {
+      // do nothing
+    }
+  }
+}

package/src/features/metrics/constants.js

@@ -0,0 +1,7 @@
+import { FEATURE_NAMES } from '../../loaders/features/features'
+
+export const FEATURE_NAME = FEATURE_NAMES.metrics
+export const SUPPORTABILITY_METRIC = 'sm'
+export const CUSTOM_METRIC = 'cm'
+export const SUPPORTABILITY_METRIC_CHANNEL = 'storeSupportabilityMetrics'
+export const CUSTOM_METRIC_CHANNEL = 'storeEventMetrics'

package/src/features/metrics/index.js

@@ -0,0 +1 @@
+export { Instrument as Metrics } from './instrument/index'