@newrelic/browser-agent 1.236.0 → 1.237.1

package/dist/esm/common/config/state/runtime.js

@@ -23,7 +23,8 @@ const model = {
   releaseIds: {},
   session: undefined,
   xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-  version: VERSION
+  version: VERSION,
+  denyList: undefined
 };
 const _cache = {};
 export function getRuntime(id) {

package/dist/esm/common/constants/env.cdn.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.236.0";
+export const VERSION = "1.237.1";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/constants/env.npm.js

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.236.0";
+export const VERSION = "1.237.1";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/deny-list/deny-list.js

@@ -40,24 +40,28 @@ export function setDenyList(denyListConfig) {
     return;
   }
   for (var i = 0; i < denyListConfig.length; i++) {
-    var url = denyListConfig[i];
+    let url = denyListConfig[i];
+    if (!url) continue; // ignore bad values like undefined or empty strings
+
     if (url.indexOf('http://') === 0) {
       url = url.substring(7);
     } else if (url.indexOf('https://') === 0) {
       url = url.substring(8);
     }
-    var firstSlash = url.indexOf('/');
+    const firstSlash = url.indexOf('/');
+    let host, pathname;
     if (firstSlash > 0) {
-      denyList.push({
-        hostname: url.substring(0, firstSlash),
-        pathname: url.substring(firstSlash)
-      });
+      host = url.substring(0, firstSlash);
+      pathname = url.substring(firstSlash);
     } else {
-      denyList.push({
-        hostname: url,
-        pathname: ''
-      });
+      host = url;
+      pathname = '';
     }
+    let [hostname, port] = host.split(':');
+    denyList.push({
+      hostname,
+      pathname
+    });
   }
 }
 /**

package/dist/esm/common/harvest/harvest.js

@@ -16,6 +16,8 @@ import { applyFnToProps } from '../util/traverse';
 import { SharedContext } from '../context/shared-context';
 import { VERSION } from "../constants/env.npm";
 import { isWorkerScope, isIE } from '../constants/runtime';
+import { warn } from '../util/console';
+const warnings = {};
 
 /**
  * @typedef {import('./types.js').NetworkSendSpec} NetworkSendSpec
@@ -24,7 +26,6 @@ import { isWorkerScope, isIE } from '../constants/runtime';
  * @typedef {import('./types.js').FeatureHarvestCallback} FeatureHarvestCallback
  * @typedef {import('./types.js').FeatureHarvestCallbackOptions} FeatureHarvestCallbackOptions
  */
-
 export class Harvest extends SharedContext {
   constructor(parent) {
     super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
@@ -135,13 +136,15 @@ export class Harvest extends SharedContext {
       payloadParams = payloadParams.substring(1);
     }
     const fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
-    const gzip = qs.content_encoding === 'gzip';
+    const gzip = !!qs?.attributes?.includes('gzip');
     if (!gzip) {
       if (endpoint === 'events') {
         body = body.e;
       } else {
         body = stringify(body);
       }
+      /** Warn --once per endpoint-- if the agent tries to send large payloads */
+      if (body.length > 750000 && (warnings[endpoint] = (warnings?.[endpoint] || 0) + 1) === 1) warn("The Browser Agent is attempting to send a very large payload to /".concat(endpoint, ". This is usually tied to large amounts of custom attributes. Please check your configurations."));
     }
     if (!body || body.length === 0 || body === '{}' || body === '[]') {
       // If body is null, undefined, or an empty object or array, send an empty string instead
@@ -188,23 +191,6 @@ export class Harvest extends SharedContext {
         cbFinished(cbResult);
       }, eventListenerOpts(false));
     }
-
-    // if beacon request failed, retry with an alternative method -- will not happen for workers
-    if (!result && submitMethod === submitData.beacon) {
-      // browsers that support sendBeacon also support fetch with keepalive - IE will not retry unload calls
-      submitMethod = submitData.fetchKeepAlive;
-      try {
-        submitMethod({
-          url: fullUrl,
-          body,
-          headers
-        });
-      } catch (e) {
-        // Ignore error in final harvest
-      } finally {
-        result = true;
-      }
-    }
     return result;
   }
 
@@ -264,9 +250,8 @@ export class Harvest extends SharedContext {
   cleanPayload() {
     let payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     const clean = input => {
-      if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array) {
-        return input.length > 0 ? input : null;
-      }
+      if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array || Array.isArray(input)) return input;
+      if (typeof input === 'string') return input.length > 0 ? input : null;
       return Object.entries(input || {}).reduce((accumulator, _ref2) => {
         let [key, value] = _ref2;
         if (typeof value === 'number' || typeof value === 'string' && value.length > 0 || typeof value === 'object' && Object.keys(value || {}).length > 0) {

package/dist/esm/common/util/submit-data.js

@@ -7,7 +7,7 @@
 import { isBrowserScope, supportsSendBeacon } from '../constants/runtime';
 
 /**
- * @typedef {xhr|fetchKeepAlive|beacon} NetworkMethods
+ * @typedef {xhr|beacon} NetworkMethods
  */
 
 /**
@@ -64,36 +64,6 @@ export function xhr(_ref) {
   return request;
 }
 
-/**
- * Send via fetch with keepalive true
- * @param {Object} args - The args.
- * @param {string} args.url - The URL to send to.
- * @param {string=} args.body - The Stringified body.
- * @param {string=} [args.method=POST] - The XHR method to use.
- * @param {{key: string, value: string}[]} [args.headers] - The headers to attach.
- * @returns {XMLHttpRequest}
- */
-export function fetchKeepAlive(_ref2) {
-  let {
-    url,
-    body = null,
-    method = 'POST',
-    headers = [{
-      key: 'content-type',
-      value: 'text/plain'
-    }]
-  } = _ref2;
-  return fetch(url, {
-    method,
-    headers: headers.reduce((aggregator, header) => {
-      aggregator.push([header.key, header.value]);
-      return aggregator;
-    }, []),
-    body,
-    keepalive: true
-  });
-}
-
 /**
  * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
  * @param {Object} args - The args
@@ -101,11 +71,11 @@ export function fetchKeepAlive(_ref2) {
  * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-export function beacon(_ref3) {
+export function beacon(_ref2) {
   let {
     url,
     body
-  } = _ref3;
+  } = _ref2;
   try {
     // Navigator has to be bound to ensure it does not error in some browsers
     // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
@@ -113,8 +83,7 @@ export function beacon(_ref3) {
     return send(url, body);
   } catch (err) {
     // if sendBeacon still trys to throw an illegal invocation error,
-    // we can catch here and return.  The harvest module will fallback to use
-    // fetchKeepAlive to try to send
+    // we can catch here and return
     return false;
   }
 }

package/dist/esm/common/wrap/wrap-jsonp.js

@@ -86,13 +86,19 @@ export function wrapJsonP(sharedEE) {
     var matches = src.match(CALLBACK_REGEX);
     return matches ? matches[1] : null;
   }
+
+  /**
+   * Traverse a nested object using a '.'-delimited string wherein each substring piece maps to each subsequent object property layer.
+   * @param {string} longKey
+   * @param {object} obj
+   * @returns The final nested object referred to by initial longKey.
+   */
   function discoverValue(longKey, obj) {
-    var matches = longKey.match(VALUE_REGEX);
-    var key = matches[1];
-    var remaining = matches[3];
-    if (!remaining) {
-      return obj[key];
-    }
+    if (!longKey) return obj; // end of object recursion depth when no more key levels
+    const matches = longKey.match(VALUE_REGEX);
+    // if 'longKey' was not undefined, that is it at least had 1 level left, then the regexp would've at least matched 1st group
+    const key = matches[1];
+    const remaining = matches[3];
     return discoverValue(remaining, obj[key]);
   }
   function discoverParent(key) {

package/dist/esm/features/ajax/aggregate/index.js

@@ -6,7 +6,7 @@ import { registerHandler as register } from '../../../common/event-emitter/regis
 import { stringify } from '../../../common/util/stringify';
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer';
 import { handle } from '../../../common/event-emitter/handle';
-import { getConfigurationValue, getInfo } from '../../../common/config/config';
+import { getConfiguration, getInfo, getRuntime } from '../../../common/config/config';
 import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler';
 import { setDenyList, shouldCollectEvent } from '../../../common/deny-list/deny-list';
 import { FEATURE_NAME } from '../constants';
@@ -18,13 +18,22 @@ export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME;
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME);
+    const agentInit = getConfiguration(agentIdentifier);
+    const allAjaxIsEnabled = agentInit.ajax.enabled !== false;
+    register('xhr', storeXhr, this.featureName, this.ee);
+    if (!allAjaxIsEnabled) {
+      drain(this.agentIdentifier, this.featureName);
+      return; // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
+    }
+
+    const denyList = getRuntime(agentIdentifier).denyList;
+    setDenyList(denyList);
     let ajaxEvents = [];
     let spaAjaxEvents = {};
     let sentAjaxEvents = [];
-    let scheduler;
     const ee = this.ee;
-    const harvestTimeSeconds = getConfigurationValue(agentIdentifier, 'ajax.harvestTimeSeconds') || 10;
-    const MAX_PAYLOAD_SIZE = getConfigurationValue(agentIdentifier, 'ajax.maxPayloadSize') || 1000000;
+    const harvestTimeSeconds = agentInit.ajax.harvestTimeSeconds || 10;
+    const MAX_PAYLOAD_SIZE = agentInit.ajax.maxPayloadSize || 1000000;
 
     // Exposes these methods to browser test files -- future TO DO: can be removed once these fns are extracted from the constructor into class func
     this.storeXhr = storeXhr;
@@ -41,24 +50,22 @@ export class Aggregate extends AggregateBase {
       delete spaAjaxEvents[interaction.id];
     });
     ee.on('interactionDiscarded', interaction => {
-      if (!spaAjaxEvents[interaction.id] || !allAjaxIsEnabled()) return;
+      if (!spaAjaxEvents[interaction.id]) return;
       spaAjaxEvents[interaction.id].forEach(function (item) {
         // move it from the spaAjaxEvents buffer to the ajaxEvents buffer for harvesting here
         ajaxEvents.push(item);
       });
       delete spaAjaxEvents[interaction.id];
     });
-    if (allAjaxIsEnabled()) setDenyList(getConfigurationValue(agentIdentifier, 'ajax.deny_list'));
-    register('xhr', storeXhr, this.featureName, this.ee);
-    if (allAjaxIsEnabled()) {
-      scheduler = new HarvestScheduler('events', {
-        onFinished: onEventsHarvestFinished,
-        getPayload: prepareHarvest
-      }, this);
-      ee.on("drain-".concat(this.featureName), () => {
-        scheduler.startTimer(harvestTimeSeconds);
-      });
-    }
+    const scheduler = new HarvestScheduler('events', {
+      onFinished: onEventsHarvestFinished,
+      getPayload: prepareHarvest
+    }, this);
+    ee.on("drain-".concat(this.featureName), () => {
+      scheduler.startTimer(harvestTimeSeconds);
+    });
+    drain(this.agentIdentifier, this.featureName);
+    return;
     function storeXhr(params, metrics, startTime, endTime, type) {
       metrics.time = startTime;
 
@@ -73,9 +80,7 @@ export class Aggregate extends AggregateBase {
 
       // store as metric
       aggregator.store('xhr', hash, params, metrics);
-      if (!allAjaxIsEnabled()) {
-        return;
-      }
+      if (!allAjaxIsEnabled) return;
       if (!shouldCollectEvent(params)) {
         if (params.hostname === getInfo(agentIdentifier).errorBeacon) {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee);
@@ -157,7 +162,7 @@ export class Aggregate extends AggregateBase {
       return tooBig ? getPayload(events, maxPayloadSize, ++chunks) : payload;
     }
     function onEventsHarvestFinished(result) {
-      if (result.retry && sentAjaxEvents.length > 0 && allAjaxIsEnabled()) {
+      if (result.retry && sentAjaxEvents.length > 0) {
         ajaxEvents.unshift(...sentAjaxEvents);
         sentAjaxEvents = [];
       }
@@ -206,13 +211,5 @@ export class Aggregate extends AggregateBase {
         return this.payload.length * 2 > maxPayloadSize;
       };
     }
-    function allAjaxIsEnabled() {
-      var enabled = getConfigurationValue(agentIdentifier, 'ajax.enabled');
-      if (enabled === false) {
-        return false;
-      }
-      return true;
-    }
-    drain(this.agentIdentifier, this.featureName);
   }
 }

package/dist/esm/features/jserrors/aggregate/compute-stack-trace.js

@@ -222,7 +222,7 @@ function computeStackTraceBySourceAndLine(ex) {
       mode: 'sourceline',
       name: className,
       message: ex.message,
-      stackString: getClassName(ex) + ': ' + ex.message + '\n    in evaluated code',
+      stackString: className + ': ' + ex.message + '\n    in evaluated code',
       frames: [{
         func: 'evaluated code'
       }]

package/dist/esm/features/jserrors/constants.js

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

package/dist/esm/features/jserrors/instrument/index.js

@@ -5,63 +5,53 @@
 
 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 './debug';
 import { InstrumentBase } from '../../utils/instrument-base';
-import { FEATURE_NAME, NR_ERR_PROP } from '../constants';
+import { FEATURE_NAME } from '../constants';
 import { FEATURE_NAMES } from '../../../loaders/features/features';
 import { globalScope } from '../../../common/constants/runtime';
 import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts';
-import { getRuntime } from '../../../common/config/config';
 import { stringify } from '../../../common/util/stringify';
+import { UncaughtError } from './uncaught-error';
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME;
+  #seenErrors = new Set();
   constructor(agentIdentifier, aggregator) {
     let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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 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) {
-      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;
-        handle('err', [err, now()], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee);
-      }
-    });
-    thisInstrument.ee.on('fn-end', function () {
-      if (!thisInstrument.abortHandler) return;
-      if (!this.thrown && thisInstrument.skipNext > 0) thisInstrument.skipNext -= 1;
+
+    // Capture function errors early in case the spa feature is loaded
+    this.ee.on('fn-err', (args, obj, error) => {
+      if (!this.abortHandler || this.#seenErrors.has(error)) return;
+      this.#seenErrors.add(error);
+      handle('err', [this.#castError(error), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
     });
-    thisInstrument.ee.on('internal-error', function (e) {
-      handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, thisInstrument.ee);
+    this.ee.on('internal-error', error => {
+      if (!this.abortHandler) return;
+      handle('ierr', [this.#castError(error), now(), true], undefined, FEATURE_NAMES.jserrors, this.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, {
+    globalScope.addEventListener('unhandledrejection', promiseRejectionEvent => {
+      if (!this.abortHandler) return;
+      handle('err', [this.#castPromiseRejectionEvent(promiseRejectionEvent), 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);
+    globalScope.addEventListener('error', errorEvent => {
+      if (!this.abortHandler) return;
+
+      /**
+       * If the spa feature is loaded, errors may already have been captured in the `fn-err` listener above.
+       * This ensures those errors are not captured twice.
+       */
+      if (this.#seenErrors.has(errorEvent.error)) {
+        this.#seenErrors.delete(errorEvent.error);
+        return;
+      }
+      handle('err', [this.#castErrorEvent(errorEvent), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
+    }, eventListenerOpts(false, this.removeOnAbort?.signal));
     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();
   }
@@ -69,65 +59,66 @@ export class Instrument extends InstrumentBase {
   /** Restoration and resource release tasks to be done if JS error loader is being aborted. Unwind changes to globals. */
   #abort() {
     this.removeOnAbort?.abort();
+    this.#seenErrors.clear();
     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
+   * Any value can be used with the `throw` keyword. This function ensures that the value is
+   * either a proper Error instance or attempts to convert it to an UncaughtError instance.
+   * @param {any} error The value thrown
+   * @returns {Error|UncaughtError} The converted error instance
    */
-  onerrorHandler(message, filename, lineno, column, errorObj) {
-    if (typeof this.origOnerror === 'function') this.origOnerror(...arguments);
-    try {
-      if (this.skipNext) this.skipNext -= 1;else handle('err', [errorObj || new UncaughtException(message, filename, lineno), now()], undefined, FEATURE_NAMES.jserrors, this.ee);
-    } catch (e) {
+  #castError(error) {
+    if (error instanceof Error) {
+      return error;
+    }
+
+    /**
+     * The thrown value may contain a message property. If it does, try to treat the thrown
+     * value as an Error-like object.
+     */
+    if (typeof error?.message !== 'undefined') {
+      return new UncaughtError(error.message, error.filename || error.sourceURL, error.lineno || error.line, error.colno || error.col);
+    }
+    return new UncaughtError(typeof error === 'string' ? error : stringify(error));
+  }
+
+  /**
+   * Attempts to convert a PromiseRejectionEvent object to an Error object
+   * @param {PromiseRejectionEvent} unhandledRejectionEvent The unhandled promise rejection event
+   * @returns {Error} An Error object with the message as the casted reason
+   */
+  #castPromiseRejectionEvent(promiseRejectionEvent) {
+    let prefix = 'Unhandled Promise Rejection: ';
+    if (promiseRejectionEvent?.reason instanceof Error) {
       try {
-        handle('ierr', [e, now(), true], undefined, FEATURE_NAMES.jserrors, this.ee);
-      } catch (err) {
-        // do nothing
+        promiseRejectionEvent.reason.message = prefix + promiseRejectionEvent.reason.message;
+        return promiseRejectionEvent.reason;
+      } catch (e) {
+        return promiseRejectionEvent.reason;
       }
     }
-    return false; // maintain default behavior of the error event of Window
+    if (typeof promiseRejectionEvent.reason === 'undefined') return new UncaughtError(prefix);
+    const error = this.#castError(promiseRejectionEvent.reason);
+    error.message = prefix + error.message;
+    return error;
   }
-}
-
-/**
- *
- * @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;
-}
 
-/**
- * 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;
+  /**
+   * Attempts to convert an ErrorEvent object to an Error object
+   * @param {ErrorEvent} errorEvent The error event
+   * @returns {Error|UncaughtError} The error event converted to an Error object
+   */
+  #castErrorEvent(errorEvent) {
+    if (errorEvent.error instanceof Error) {
+      return errorEvent.error;
     }
-  }
-  if (typeof reason === 'undefined') return new Error(prefix);
-  try {
-    return new Error(prefix + stringify(reason));
-  } catch (err) {
-    return new Error(prefix);
+
+    /**
+     * Older browsers do not contain the `error` property on the ErrorEvent instance.
+     * https://caniuse.com/mdn-api_errorevent_error
+     */
+    return new UncaughtError(errorEvent.message, errorEvent.filename, errorEvent.lineno, errorEvent.colno);
   }
 }

package/dist/esm/features/jserrors/instrument/uncaught-error.js

@@ -0,0 +1,15 @@
+/**
+ * Represents an uncaught non Error type error. This class does
+ * not extend the Error class to prevent an invalid stack trace
+ * from being created. Use this class to cast thrown errors that
+ * do not use the Error class (strings, etc) to an object.
+ */
+export class UncaughtError {
+  constructor(message, filename, lineno, colno) {
+    this.name = 'UncaughtError';
+    this.message = message;
+    this.sourceURL = filename;
+    this.line = lineno;
+    this.column = colno;
+  }
+}

package/dist/esm/features/metrics/aggregate/index.js

@@ -148,6 +148,14 @@ export class Aggregate extends AggregateBase {
       // Capture metrics for size of custom attributes
       const jsAttributes = stringify(info.jsAttributes);
       this.storeSupportabilityMetrics('PageSession/Feature/CustomData/Bytes', jsAttributes === '{}' ? 0 : jsAttributes.length);
+
+      // Capture metrics for performance markers and measures
+      if (typeof performance !== 'undefined') {
+        const markers = performance.getEntriesByType('mark');
+        const measures = performance.getEntriesByType('measure');
+        this.storeSupportabilityMetrics('Generic/Performance/Mark/Seen', markers.length);
+        this.storeSupportabilityMetrics('Generic/Performance/Measure/Seen', measures.length);
+      }
     } catch (e) {
       // do nothing
     }

package/dist/esm/features/page_view_event/aggregate/initialized-features.js

@@ -1,4 +1,5 @@
 import { FEATURE_NAMES } from '../../../loaders/features/features';
+import { gosNREUM } from '../../../common/window/nreum';
 
 /**
  * Get an array of flags required by downstream (NR UI) based on the features initialized in this agent
@@ -8,25 +9,28 @@ import { FEATURE_NAMES } from '../../../loaders/features/features';
  */
 export function getActivatedFeaturesFlags(agentId) {
   const flagArr = [];
-  Object.keys(newrelic.initializedAgents[agentId].features).forEach(featName => {
-    switch (featName) {
-      case FEATURE_NAMES.ajax:
-        flagArr.push('xhr');
-        break;
-      case FEATURE_NAMES.jserrors:
-        flagArr.push('err');
-        break;
-      case FEATURE_NAMES.pageAction:
-        flagArr.push('ins');
-        break;
-      case FEATURE_NAMES.sessionTrace:
-        flagArr.push('stn');
-        break;
-      case FEATURE_NAMES.spa:
-        flagArr.push('spa');
-        break;
-    }
-  });
+  const newrelic = gosNREUM();
+  try {
+    Object.keys(newrelic.initializedAgents[agentId].features).forEach(featName => {
+      switch (featName) {
+        case FEATURE_NAMES.ajax:
+          flagArr.push('xhr');
+          break;
+        case FEATURE_NAMES.jserrors:
+          flagArr.push('err');
+          break;
+        case FEATURE_NAMES.pageAction:
+          flagArr.push('ins');
+          break;
+        case FEATURE_NAMES.sessionTrace:
+          flagArr.push('stn');
+          break;
+        case FEATURE_NAMES.spa:
+          flagArr.push('spa');
+          break;
+      }
+    });
+  } catch (e) {}
   return flagArr;
 }