@newrelic/browser-agent 1.237.1 → 1.239.0

package/dist/esm/common/constants/shared-channel.js

@@ -5,7 +5,9 @@
  */
 
 let onReplayReady;
-const sessionReplayInitialized = new Promise(resolve => onReplayReady = resolve);
+const sessionReplayInitialized = new Promise(resolve => {
+  onReplayReady = resolve;
+});
 export const sharedChannel = Object.freeze({
   onReplayReady,
   sessionReplayInitialized

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

@@ -57,7 +57,7 @@ export function setDenyList(denyListConfig) {
       host = url;
       pathname = '';
     }
-    let [hostname, port] = host.split(':');
+    let [hostname] = host.split(':');
     denyList.push({
       hostname,
       pathname
@@ -74,10 +74,7 @@ function domainMatchesPattern(pattern, domain) {
   if (pattern.length > domain.length) {
     return false;
   }
-  if (domain.indexOf(pattern) === domain.length - pattern.length) {
-    return true;
-  }
-  return false;
+  return domain.indexOf(pattern) === domain.length - pattern.length;
 }
 
 /**
@@ -98,8 +95,5 @@ function comparePath(pattern, path) {
   if (pattern === '') {
     return true;
   }
-  if (pattern === path) {
-    return true;
-  }
-  return false;
+  return pattern === path;
 }

package/dist/esm/common/drain/drain.js

@@ -48,7 +48,6 @@ export function drain() {
   let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
   let featureName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'feature';
   curateRegistry(agentIdentifier);
-
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
   // This could happen in tests, or loaders that directly import the aggregator. In these cases it is safe to
   // drain the feature group immediately rather than waiting to drain all at once.
@@ -67,6 +66,7 @@ export function drain() {
     items.sort((a, b) => a[1].priority - b[1].priority);
     items.forEach(_ref2 => {
       let [group] = _ref2;
+      registry[agentIdentifier].delete(group);
       drainGroup(group);
     });
   }

package/dist/esm/common/event-emitter/contextual-ee.js

@@ -5,21 +5,21 @@
 
 import { gosNREUM } from '../window/nreum';
 import { getOrSet } from '../util/get-or-set';
-import { mapOwn } from '../util/map-own';
 import { getRuntime } from '../config/config';
-var ctxId = 'nr@context';
+import { EventContext } from './event-context';
+import { bundleId } from '../ids/bundle-id';
 
+// create a unique id to store event context data for the current agent bundle
+const contextId = "nr@context:".concat(bundleId);
 // create global emitter instance that can be shared among bundles
-let nr = gosNREUM();
-var globalInstance;
-if (nr.ee) {
-  globalInstance = nr.ee;
-} else {
-  globalInstance = ee(undefined, 'globalEE');
+const globalInstance = ee(undefined, 'globalEE');
+
+// Only override the exposed event emitter if one has not already been exposed
+const nr = gosNREUM();
+if (!nr.ee) {
   nr.ee = globalInstance;
 }
-export { globalInstance as ee };
-function EventContext() {}
+export { globalInstance as ee, contextId };
 function ee(old, debugId) {
   var handlers = {};
   var bufferGroupMap = {};
@@ -38,16 +38,16 @@ function ee(old, debugId) {
   }
   var emitter = {
     on: addEventListener,
-    addEventListener: addEventListener,
-    removeEventListener: removeEventListener,
-    emit: emit,
+    addEventListener,
+    removeEventListener,
+    emit,
     get: getOrCreate,
-    listeners: listeners,
-    context: context,
+    listeners,
+    context,
     buffer: bufferEventsByGroup,
     abort,
     aborted: false,
-    isBuffering: isBuffering,
+    isBuffering,
     debugId,
     backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
   };
@@ -56,9 +56,9 @@ function ee(old, debugId) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore;
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ctxId, getNewContext);
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId));
     } else {
-      return getNewContext();
+      return new EventContext(contextId);
     }
   }
   function emit(type, args, contextOrStore, force, bubble) {
@@ -105,12 +105,13 @@ function ee(old, debugId) {
     return emitters[name] = emitters[name] || ee(emitter, name);
   }
   function bufferEventsByGroup(types, group) {
-    var eventBuffer = getBuffer();
+    const eventBuffer = getBuffer();
+    group = group || 'feature';
 
     // do not buffer events if agent has been aborted
     if (emitter.aborted) return;
-    mapOwn(types, function (i, type) {
-      group = group || 'feature';
+    Object.entries(types || {}).forEach(_ref => {
+      let [_, type] = _ref;
       bufferGroupMap[type] = group;
       if (!(group in eventBuffer)) {
         eventBuffer[group] = [];
@@ -128,14 +129,6 @@ function ee(old, debugId) {
     return emitter.backlog;
   }
 }
-
-// get context object from store object, or create if does not exist
-export function getOrSetContext(obj) {
-  return getOrSet(obj, ctxId, getNewContext);
-}
-function getNewContext() {
-  return new EventContext();
-}
 function abort() {
   globalInstance.aborted = true;
   globalInstance.backlog = {};

package/dist/esm/common/event-emitter/event-context.js

@@ -0,0 +1,5 @@
+export class EventContext {
+  constructor(contextId) {
+    this.contextId = contextId;
+  }
+}

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

@@ -7,7 +7,6 @@ import * as submitData from '../util/submit-data';
 import { SharedContext } from '../context/shared-context';
 import { Harvest } from './harvest';
 import { subscribeToEOL } from '../unload/eol';
-import { getConfigurationValue } from '../config/config';
 import { SESSION_EVENTS } from '../session/session-entity';
 
 /**
@@ -36,7 +35,7 @@ export class HarvestScheduler extends SharedContext {
     this.harvest = new Harvest(this.sharedContext);
 
     // unload if EOL mechanism fires
-    subscribeToEOL(this.unload.bind(this), getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')); // TO DO: remove feature flag after rls stable
+    subscribeToEOL(this.unload.bind(this));
 
     /* Flush all buffered data if session resets and give up retries. This should be synchronous to ensure that the correct `session` value is sent.
       Since session-reset generates a new session ID and the ID is grabbed at send-time, any delays or retries would cause the payload to be sent under
@@ -103,7 +102,7 @@ export class HarvestScheduler extends SharedContext {
       if (!submitMethod) return false;
       const retry = !opts?.unload && submitMethod === submitData.xhr;
       payload = this.opts.getPayload({
-        retry: retry
+        retry
       });
       if (!payload) {
         if (this.started) {
@@ -139,7 +138,6 @@ export class HarvestScheduler extends SharedContext {
     if (this.started) {
       this.scheduleHarvest();
     }
-    return;
   }
   onHarvestFinished(opts, result) {
     if (this.opts.onFinished) {

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

@@ -48,7 +48,8 @@ export class Harvest extends SharedContext {
       isFinalHarvest: spec.opts?.unload
     });
     const options = {
-      retry: !spec.opts?.unload && submitMethod === submitData.xhr
+      retry: !spec.opts?.unload && submitMethod === submitData.xhr,
+      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);
@@ -122,7 +123,8 @@ export class Harvest extends SharedContext {
       }
       return false;
     }
-    let url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpoint !== 'rum' ? "/".concat(endpoint) : '', "/1/").concat(info.licenseKey);
+    const endpointURLPart = endpoint !== 'rum' ? "/".concat(endpoint) : '';
+    let url = "".concat(this.getScheme(), "://").concat(info.errorBeacon).concat(endpointURLPart, "/1/").concat(info.licenseKey);
     if (customUrl) url = customUrl;
     if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);
     const baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
@@ -150,11 +152,6 @@ export class Harvest extends SharedContext {
       // If body is null, undefined, or an empty object or array, send an empty string instead
       body = '';
     }
-
-    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
-    // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.length || 0;
     const headers = [];
     headers.push({
       key: 'content-type',

package/dist/esm/common/ids/bundle-id.js

@@ -0,0 +1,13 @@
+/**
+ * @file Contains a unique identifier for the running agent bundle
+ * when loaded.
+ * @copyright 2023 New Relic Corporation. All rights reserved.
+ * @license Apache-2.0
+ */
+
+import { generateUuid } from './unique-id';
+
+/**
+ * Provides a unique id for the current agent bundle
+ */
+export const bundleId = generateUuid();

package/dist/esm/common/serialize/bel-serializer.js

@@ -25,7 +25,7 @@ export function getAddStringContext(agentIdentifier) {
   function addString(str) {
     if (typeof str === 'undefined' || str === '') return '';
     var obfuscator = new Obfuscator({
-      agentIdentifier: agentIdentifier
+      agentIdentifier
     });
     str = String(str);
     if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str);

package/dist/esm/common/session/session-entity.js

@@ -40,33 +40,37 @@ export class SessionEntity {
    * expiresMs and inactiveMs are used to "expire" the session, but can be overridden in the constructor. Pass 0 to disable expiration timers.
    */
   constructor(opts) {
-    this.setup(opts);
-  }
-  setup(_ref) {
-    let {
+    const {
       agentIdentifier,
       key,
-      storage,
-      value = generateRandomHexString(16),
-      expiresMs = DEFAULT_EXPIRES_MS,
-      inactiveMs = DEFAULT_INACTIVE_MS
-    } = _ref;
+      storage
+    } = opts;
     if (!agentIdentifier || !key || !storage) {
       throw new Error("Missing required field(s):".concat(!agentIdentifier ? ' agentID' : '').concat(!key ? ' key' : '').concat(!storage ? ' storage' : ''));
     }
     this.agentIdentifier = agentIdentifier;
     this.storage = storage;
     this.state = {};
-    this.sync(model);
 
     // key is intended to act as the k=v pair
     this.key = key;
+    this.ee = ee.get(agentIdentifier);
+    wrapEvents(this.ee);
+    this.setup(opts);
+  }
+  setup(_ref) {
+    let {
+      value = generateRandomHexString(16),
+      expiresMs = DEFAULT_EXPIRES_MS,
+      inactiveMs = DEFAULT_INACTIVE_MS
+    } = _ref;
+    this.state = {};
+    this.sync(model);
+
     // value is intended to act as the primary value of the k=v pair
     this.state.value = value;
     this.expiresMs = expiresMs;
     this.inactiveMs = inactiveMs;
-    this.ee = ee.get(agentIdentifier);
-    wrapEvents(this.ee);
 
     // the first time the session entity class is instantiated, we check the storage API for an existing
     // object. If it exists, the values inside the object are used to inform the timers that run locally.

package/dist/esm/common/storage/first-party-cookies.js

@@ -7,22 +7,23 @@ export class FirstPartyCookies {
       var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
       if (match) return match[2];
     } catch (err) {
+      // Error is ignored
       return '';
     }
   }
   set(key, value) {
     try {
-      const cookie = "".concat(key, "=").concat(value, "; Domain=").concat(domain, "; Path=/");
+      const cookie = "".concat(key, "=").concat(value, "; Domain=").concat(this.domain, "; Path=/");
       document.cookie = cookie;
     } catch (err) {
-      return;
+      // Error is ignored
     }
   }
   remove(key) {
     try {
-      return document.cookie = "".concat(key, "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=").concat(domain, "; Path=/");
+      document.cookie = "".concat(key, "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=").concat(this.domain, "; Path=/");
     } catch (err) {
-      return;
+      // Error is ignored
     }
   }
 }

package/dist/esm/common/storage/local-storage.js

@@ -5,6 +5,7 @@ export class LocalStorage {
       // Cast it back to undefined if it doesnt exist
       return localStorage.getItem(key) || undefined;
     } catch (err) {
+      // Error is ignored
       return '';
     }
   }
@@ -13,14 +14,14 @@ export class LocalStorage {
       if (value === undefined || value === null) return this.remove(key);
       return localStorage.setItem(key, value);
     } catch (err) {
-      return;
+      // Error is ignored
     }
   }
   remove(key) {
     try {
       localStorage.removeItem(key);
     } catch (err) {
-      return;
+      // Error is ignored
     }
   }
 }

package/dist/esm/common/timer/interaction-timer.js

@@ -21,14 +21,16 @@ export class InteractionTimer extends Timer {
     }
     if (isBrowserScope && opts.ee) {
       if (opts.ee) {
+        this.ee = opts.ee;
         const debouncedRefresh = debounce(this.refresh.bind(this), 500, {
           leading: true
         });
-        opts.ee.on('fn-end', evts => {
+        this.refreshHandler = evts => {
           if (opts.refreshEvents.includes(evts?.[0]?.type)) {
             debouncedRefresh();
           }
-        });
+        };
+        opts.ee.on('fn-end', this.refreshHandler);
       }
 
       // watch for the vis state changing.  If the page is hidden, the local inactivity timer should be paused
@@ -42,22 +44,28 @@ export class InteractionTimer extends Timer {
       subscribeToVisibilityChange(state => {
         if (state === 'hidden') this.pause();
         // vis change --> visible is treated like a new interaction with the page
-        else {
-          this.refresh();
-          this.onResume(); // emit resume event after state updated
-        }
+        else this.resume();
       }, false, false, this.abortController?.signal);
     }
   }
   abort() {
     this.clear();
     this.abortController?.abort();
+    if (this.refreshHandler) {
+      this.ee.removeEventListener('fn-end', this.refreshHandler);
+      this.refreshHandler = this.ee = null;
+    }
   }
   pause() {
     this.onPause();
     clearTimeout(this.timer);
     this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp);
   }
+  resume() {
+    this.refresh();
+    this.onResume(); // emit resume event after state updated
+  }
+
   refresh(cb, ms) {
     this.clear();
     this.timer = this.create(cb, ms);

package/dist/esm/common/timing/nav-timing.js

@@ -26,7 +26,7 @@ var LOAD_EVENT = 'loadEvent';
 var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent';
 export var navTimingValues = [];
 function getPntType(type) {
-  if (typeof type == 'number') return type;
+  if (typeof type === 'number') return type;
   const types = {
     navigate: undefined,
     reload: 1,

package/dist/esm/common/unload/eol.js

@@ -3,8 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { windowAddEventListener } from '../event-listener/event-listener-opts';
-import { single } from '../util/invoke';
-import { ffVersion, globalScope, isWorkerScope, isBrowserScope } from '../constants/runtime';
+import { globalScope, isWorkerScope, isBrowserScope } from '../constants/runtime';
 import { subscribeToVisibilityChange } from '../window/page-visibility';
 if (isWorkerScope) {
   globalScope.cleanupTasks = []; // create new list on WorkerGlobalScope to track funcs to run before exiting thread
@@ -23,37 +22,12 @@ if (isWorkerScope) {
  * Subscribes a provided callback to the time/event when the agent should treat it as end-of-life.
  * This is used, for example, to submit a final harvest and send all remaining data on best-effort.
  * @param {function} cb - func to run before or during the last reliable event or time of an env's life span
- * @param {boolean} allowBFCache - (temp) feature flag to gate new v1222 BFC support
  */
-export function subscribeToEOL(cb, allowBFCache) {
+export function subscribeToEOL(cb) {
   if (isBrowserScope) {
-    if (allowBFCache) {
-      subscribeToVisibilityChange(cb, true); // when user switches tab or hides window, esp. mobile scenario
-      windowAddEventListener('pagehide', cb); // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
-      // --this ought to be removed once support for version below 14.5 phases out
-    } else {
-      var oneCall = single(cb);
-
-      // Firefox has a bug wherein a slow-loading resource loaded from the 'pagehide'
-      // or 'unload' event will delay the 'load' event firing on the next page load.
-      // In Firefox versions that support sendBeacon, this doesn't matter, because
-      // we'll use it instead of an image load for our final harvest.
-      //
-      // Some Safari versions never fire the 'unload' event for pages that are being
-      // put into the WebKit page cache, so we *need* to use the pagehide event for
-      // the final submission from Safari.
-      //
-      // Generally speaking, we will try to submit our final harvest from either
-      // pagehide or unload, whichever comes first, but in Firefox, we need to avoid
-      // attempting to submit from pagehide to ensure that we don't slow down loading
-      // of the next page.
-      if (!ffVersion || navigator.sendBeacon) {
-        windowAddEventListener('pagehide', oneCall);
-      } else {
-        windowAddEventListener('beforeunload', oneCall);
-      }
-      windowAddEventListener('unload', oneCall);
-    }
+    subscribeToVisibilityChange(cb, true); // when user switches tab or hides window, esp. mobile scenario
+    windowAddEventListener('pagehide', cb); // when user navigates away, and because safari iOS v14.4- doesn't fully support vis change
+    // --this ought to be removed once support for version below 14.5 phases out
   } else if (isWorkerScope) {
     globalScope.cleanupTasks.push(cb); // close() should run these tasks before quitting thread
   }

package/dist/esm/common/util/feature-flags.js

@@ -4,7 +4,6 @@
  */
 import { ee } from '../event-emitter/contextual-ee';
 import { handle } from '../event-emitter/handle';
-import { drain } from '../drain/drain';
 import { FEATURE_NAMES } from '../../loaders/features/features';
 const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
@@ -13,24 +12,24 @@ const bucketMap = {
   spa: [FEATURE_NAMES.spa],
   sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
 };
+const sentIds = new Set();
 
 /** Note that this function only processes each unique flag ONCE, with the first occurrence of each flag and numeric value determining its switch on/off setting. */
 export function activateFeatures(flags, agentIdentifier) {
   const sharedEE = ee.get(agentIdentifier);
   if (!(flags && typeof flags === 'object')) return;
-  Object.entries(flags).forEach(_ref => {
-    let [flag, num] = _ref;
-    if (activatedFeatures[flag] !== undefined) return;
-    if (bucketMap[flag]) {
-      bucketMap[flag].forEach(feat => {
-        if (!num) handle('block-' + flag, [], undefined, feat, sharedEE);else handle('feat-' + flag, [], undefined, feat, sharedEE);
-        handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE); // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
-      });
-    } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE); // not sure what other flags are overlooked, but there's a test for ones not in the map --
-    // ^^^ THIS DOESN'T ACTUALLY DO ANYTHHING AS UNDEFINED/FEATURE GROUP ISN'T DRAINED
-
-    activatedFeatures[flag] = Boolean(num);
-  });
+  if (!sentIds.has(agentIdentifier)) {
+    Object.entries(flags).forEach(_ref => {
+      let [flag, num] = _ref;
+      if (bucketMap[flag]) {
+        bucketMap[flag].forEach(feat => {
+          if (!num) handle('block-' + flag, [], undefined, feat, sharedEE);else handle('feat-' + flag, [], undefined, feat, sharedEE);
+          handle('rumresp-' + flag, [Boolean(num)], undefined, feat, sharedEE); // this is a duplicate of feat-/block- but makes awaiting for 1 event easier than 2
+        });
+      } else if (num) handle('feat-' + flag, [], undefined, undefined, sharedEE); // not sure what other flags are overlooked, but there's a test for ones not in the map --
+      activatedFeatures[flag] = Boolean(num);
+    });
+  }
 
   // Let the features waiting on their respective flags know that RUM response was received and that any missing flags are interpreted as bad entitlement / "off".
   // Hence, those features will not be hanging forever if their flags aren't included in the response.
@@ -40,6 +39,6 @@ export function activateFeatures(flags, agentIdentifier) {
       activatedFeatures[flag] = false;
     }
   });
-  drain(agentIdentifier, FEATURE_NAMES.pageViewEvent);
+  sentIds.add(agentIdentifier);
 }
 export const activatedFeatures = {};

package/dist/esm/common/util/invoke.js

@@ -32,7 +32,9 @@ export function debounce(func) {
     }
     if (leading && timer === undefined) {
       func.apply(_this, args);
-      timer = setTimeout(() => timer = clearTimeout(timer), timeout);
+      timer = setTimeout(() => {
+        timer = clearTimeout(timer);
+      }, timeout);
     }
     if (!leading) {
       clearTimeout(timer);

package/dist/esm/common/util/obfuscate.js

@@ -52,11 +52,9 @@ export function validateRules(rules) {
       invalidRegexDetected = true;
     }
     var replacement = rules[i].replacement;
-    if (replacement) {
-      if (typeof replacement !== 'string') {
-        warn('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)');
-        invalidReplacementDetected = true;
-      }
+    if (replacement && typeof replacement !== 'string') {
+      warn('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)');
+      invalidReplacementDetected = true;
     }
   }
   return !invalidReplacementDetected && !invalidRegexDetected;

package/dist/esm/common/util/traverse.js

@@ -20,6 +20,7 @@ export function applyFnToProps(obj, fn) {
     if (typeof obj[property] === 'object') {
       applyFnToProps(obj[property], fn, type, ignoreKeys);
     } else {
+      // eslint-disable-next-line valid-typeof
       if (typeof obj[property] === type && !ignoreKeys.includes(property)) obj[property] = fn(obj[property]);
     }
   });

package/dist/esm/common/window/page-visibility.js

@@ -15,11 +15,10 @@ export function subscribeToVisibilityChange(cb) {
   let capture = arguments.length > 2 ? arguments[2] : undefined;
   let abortSignal = arguments.length > 3 ? arguments[3] : undefined;
   documentAddEventListener('visibilitychange', handleVisibilityChange, capture, abortSignal);
-  return;
   function handleVisibilityChange() {
     if (toHiddenOnly) {
       // trigger cb on change to hidden state only
-      if (document.visibilityState == 'hidden') cb();
+      if (document.visibilityState === 'hidden') cb();
       return;
     }
     cb(document.visibilityState);

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

@@ -7,14 +7,15 @@
  * This module is used directly by: session_trace.
  * It is also called by -> wrapXhr <-, so see "wrap-xhr.js" for features that use this indirectly.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
 import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { getOrSet } from '../util/get-or-set';
 import { globalScope, isBrowserScope } from '../constants/runtime';
 const wrapped = {};
-const XHR = XMLHttpRequest;
+const XHR = globalScope.XMLHttpRequest;
 const ADD_EVENT_LISTENER = 'addEventListener';
 const REMOVE_EVENT_LISTENER = 'removeEventListener';
+const flag = "nr@wrapped:".concat(contextId);
 
 /**
  * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
@@ -43,7 +44,7 @@ export function wrapEvents(sharedEE) {
     if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {
       return;
     }
-    var wrapped = getOrSet(originalListener, 'nr@wrapped', function () {
+    var wrapped = getOrSet(originalListener, flag, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

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

@@ -6,16 +6,14 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { ee as baseEE, contextId } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
-import { flag } from './wrap-function';
 var prefix = 'fetch-';
 var bodyPrefix = prefix + 'body-';
 var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
 var Req = globalScope.Request;
 var Res = globalScope.Response;
 var proto = 'prototype';
-var ctxId = 'nr@context';
 const wrapped = {};
 
 /**
@@ -72,7 +70,7 @@ export function wrapFetch(sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx);
         var dtPayload;
-        if (ctx[ctxId] && ctx[ctxId].dt) dtPayload = ctx[ctxId].dt;
+        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt;
         var origPromiseFromFetch = fn.apply(this, args);
         ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);