@newrelic/browser-agent 1.253.0 → 1.254.0

package/dist/cjs/loaders/agent.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Agent = void 0;
-require("./configure/public-path.npm");
-require("./configure/nonce.npm");
+require("./configure/public-path");
+require("./configure/nonce");
 var _agentBase = require("./agent-base");
 var _enabledFeatures = require("./features/enabled-features");
 var _configure = require("./configure/configure");
@@ -88,8 +88,8 @@ class Agent extends _agentBase.AgentBase {
       delete newrelic.initializedAgents[this.agentIdentifier]?.features; // GC mem used internally by features
       delete this.sharedAggregator;
       // Keep the initialized agent object with its configs for troubleshooting purposes.
-      newrelic.ee?.abort(); // set flag and clear global backlog
-      delete newrelic.ee?.get(this.agentIdentifier); // clear this agent's own backlog too
+      const thisEE = newrelic.ee.get(this.agentIdentifier);
+      thisEE.abort(); // set flag and clear backlog
       return false;
     }
   }

package/dist/cjs/loaders/api/api.js

@@ -210,7 +210,7 @@ function setAPI(agentIdentifier, forceDrain) {
       (0, _drain.drain)(agentIdentifier, 'api');
     }).catch(() => {
       (0, _console.warn)('Downloading runtime APIs failed...');
-      (0, _drain.drain)(agentIdentifier, 'api', true);
+      instanceEE.abort();
     });
   }
   return apiInterface;

package/dist/cjs/loaders/configure/configure.js

@@ -9,7 +9,7 @@ var _nreum = require("../../common/window/nreum");
 var _config = require("../../common/config/config");
 var _featureFlags = require("../../common/util/feature-flags");
 var _runtime = require("../../common/constants/runtime");
-var _publicPath = require("./public-path.npm");
+var _publicPath = require("./public-path");
 let alreadySetOnce = false; // the configure() function can run multiple times in agent lifecycle
 
 /**

package/dist/cjs/loaders/configure/nonce.cdn.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/* global __webpack_require__ */
+
+__webpack_require__.nc = (() => {
+  try {
+    return document?.currentScript?.nonce;
+  } catch (ex) {
+    // Swallow error and proceed like nonce is not defined
+    // This will happen when the agent is loaded in a worker scope
+  }
+  return '';
+})();

package/dist/cjs/loaders/configure/nonce.js

@@ -1,13 +1,2 @@
-"use strict";
-
-/* global __webpack_require__ */
-
-__webpack_require__.nc = (() => {
-  try {
-    return document?.currentScript?.nonce;
-  } catch (ex) {
-    // Swallow error and proceed like nonce is not defined
-    // This will happen when the agent is loaded in a worker scope
-  }
-  return '';
-})();
+// We don't support setting automating the nonce attribute in the npm package
+"use strict";

package/dist/cjs/loaders/configure/public-path.cdn.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.redefinePublicPath = void 0;
+// Set the default CDN or remote for fetching the assets; NPM shouldn't change this var.
+
+const redefinePublicPath = urlString => {
+  const isOrigin = urlString.startsWith('http');
+  // Input is not expected to end in a slash, but webpack concats as-is, so one is inserted.
+  urlString += '/';
+  // If there's no existing HTTP scheme, the secure protocol is prepended by default.
+  __webpack_public_path__ = isOrigin ? urlString : 'https://' + urlString; // eslint-disable-line
+};
+exports.redefinePublicPath = redefinePublicPath;

package/dist/cjs/loaders/configure/public-path.js

@@ -4,13 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.redefinePublicPath = void 0;
-// Set the default CDN or remote for fetching the assets; NPM shouldn't change this var.
-
-const redefinePublicPath = urlString => {
-  const isOrigin = urlString.startsWith('http');
-  // Input is not expected to end in a slash, but webpack concats as-is, so one is inserted.
-  urlString += '/';
-  // If there's no existing HTTP scheme, the secure protocol is prepended by default.
-  __webpack_public_path__ = isOrigin ? urlString : 'https://' + urlString; // eslint-disable-line
+const redefinePublicPath = () => {
+  // We don't support setting public path in webpack via NPM build.
 };
 exports.redefinePublicPath = redefinePublicPath;

package/dist/esm/cdn/polyfills.js

@@ -21,4 +21,5 @@ import 'core-js/stable/weak-set';
 import 'core-js/stable/object/get-own-property-descriptors';
 import 'core-js/stable/url';
 import 'core-js/stable/url-search-params';
-import 'core-js/stable/string/starts-with';
+import 'core-js/stable/string/starts-with';
+import 'core-js/stable/number/is-nan';

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

@@ -17,10 +17,13 @@ const model = {
   origin: '' + globalScope.location,
   ptid: undefined,
   releaseIds: {},
+  /** Agent-specific metadata found in the RUM call response. ex. entityGuid */
+  appMetadata: {},
   session: undefined,
   xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
   version: VERSION,
-  denyList: undefined
+  denyList: undefined,
+  harvestCount: 0
 };
 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.253.0";
+export const VERSION = "1.254.0";
 
 /**
  * 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.253.0";
+export const VERSION = "1.254.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -28,13 +28,24 @@ export function registerDrain(agentIdentifier, group) {
   if (!registry[agentIdentifier].get(group)) registry[agentIdentifier].set(group, item);
 }
 
+/**
+ * Removes an item from the registry and immediately re-checks if the registry is ready to "drain all"
+ * @param {*} agentIdentifier - A 16 character string uniquely identifying the agent.
+ * @param {*} group - The named "bucket" to be removed from the registry
+ */
+export function deregisterDrain(agentIdentifier, group) {
+  curateRegistry(agentIdentifier);
+  if (registry[agentIdentifier].get(group)) registry[agentIdentifier].delete(group);
+  if (registry[agentIdentifier].size) checkCanDrainAll(agentIdentifier);
+}
+
 /**
  * Registers the specified agent with the centralized event buffer registry if it is not already registered.
  * Agents without an identifier (as in the case of some tests) will be excluded from the registry.
  * @param {string} agentIdentifier - A 16 character string uniquely identifying an agent.
  */
 function curateRegistry(agentIdentifier) {
-  if (!agentIdentifier) return;
+  if (!agentIdentifier) throw new Error('agentIdentifier required');
   if (!registry[agentIdentifier]) registry[agentIdentifier] = new Map();
 }
 
@@ -53,11 +64,15 @@ export function drain() {
   // 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.
-  if (!agentIdentifier || !registry[agentIdentifier].get(featureName) || force) return drainGroup(featureName);
+  if (!agentIdentifier || !registry[agentIdentifier].get(featureName) || force) return drainGroup(agentIdentifier, featureName);
 
   // When `drain` is called, this feature is ready to drain (staged).
   registry[agentIdentifier].get(featureName).staged = true;
+  checkCanDrainAll(agentIdentifier);
+}
 
+/** Checks all items in the registry to see if they have been "staged".  If ALL items are staged, it will drain all registry items (drainGroup).  It not, nothing will happen */
+function checkCanDrainAll(agentIdentifier) {
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
   const items = [...registry[agentIdentifier]];
@@ -69,40 +84,38 @@ export function drain() {
     items.forEach(_ref2 => {
       let [group] = _ref2;
       registry[agentIdentifier].delete(group);
-      drainGroup(group);
+      drainGroup(agentIdentifier, group);
     });
   }
+}
 
-  /**
+/**
    * Drains all the buffered (backlog) events for a particular feature's event-group by emitting each event to each of
    * the subscribed handlers for the group.
    * @param {*} group - The name of a particular feature's event "bucket".
    */
-  function drainGroup(group) {
-    const baseEE = agentIdentifier ? ee.get(agentIdentifier) : ee;
-    const handlers = defaultRegister.handlers;
-    if (!baseEE.backlog || !handlers) return;
-    var bufferedEventsInGroup = baseEE.backlog[group];
-    var groupHandlers = handlers[group];
-    if (groupHandlers) {
-      // We don't cache the length of the buffer while looping because events might still be added while processing.
-      for (var i = 0; bufferedEventsInGroup && i < bufferedEventsInGroup.length; ++i) {
-        // eslint-disable-line no-unmodified-loop-condition
-        emitEvent(bufferedEventsInGroup[i], groupHandlers);
-      }
-      mapOwn(groupHandlers, function (eventType, handlerRegistrationList) {
-        mapOwn(handlerRegistrationList, function (i, registration) {
-          // registration is an array of: [targetEE, eventHandler]
-          registration[0].on(eventType, registration[1]);
-        });
-      });
+function drainGroup(agentIdentifier, group) {
+  const baseEE = agentIdentifier ? ee.get(agentIdentifier) : ee;
+  const handlers = defaultRegister.handlers; // other storage in registerHandler
+  if (!baseEE.backlog || !handlers) return;
+  var bufferedEventsInGroup = baseEE.backlog[group];
+  var groupHandlers = handlers[group]; // each group in the registerHandler storage
+  if (groupHandlers) {
+    // We don't cache the length of the buffer while looping because events might still be added while processing.
+    for (var i = 0; bufferedEventsInGroup && i < bufferedEventsInGroup.length; ++i) {
+      // eslint-disable-line no-unmodified-loop-condition
+      emitEvent(bufferedEventsInGroup[i], groupHandlers);
     }
-    delete handlers[group];
-
-    // Keep the feature's event-group as a property of the event emitter so we know it was already created and drained.
-    baseEE.backlog[group] = null;
-    baseEE.emit('drain-' + group, []);
+    mapOwn(groupHandlers, function (eventType, handlerRegistrationList) {
+      mapOwn(handlerRegistrationList, function (i, registration) {
+        // registration is an array of: [targetEE, eventHandler]
+        registration[0].on(eventType, registration[1]);
+      });
+    });
   }
+  if (!baseEE.isolatedBacklog) delete handlers[group];
+  baseEE.backlog[group] = null;
+  baseEE.emit('drain-' + group, []);
 }
 
 /**

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

@@ -6,9 +6,11 @@
 import { gosNREUM } from '../window/nreum';
 import { getOrSet } from '../util/get-or-set';
 import { getRuntime } from '../config/config';
-import { EventContext } from '../context/event-context';
-import { ObservationContextManager } from '../context/observation-context-manager';
+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
 const globalInstance = ee(undefined, 'globalEE');
 
@@ -17,7 +19,7 @@ const nr = gosNREUM();
 if (!nr.ee) {
   nr.ee = globalInstance;
 }
-export { globalInstance as ee };
+export { globalInstance as ee, contextId };
 function ee(old, debugId) {
   var handlers = {};
   var bufferGroupMap = {};
@@ -44,20 +46,34 @@ function ee(old, debugId) {
     context,
     buffer: bufferEventsByGroup,
     abort,
-    aborted: false,
     isBuffering,
     debugId,
     backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {},
-    observationContextManager: null
+    isolatedBacklog
   };
+  function abort() {
+    emitter._aborted = true;
+    Object.keys(emitter.backlog).forEach(key => {
+      delete emitter.backlog[key];
+    });
+  }
+  Object.defineProperty(emitter, 'aborted', {
+    get: () => {
+      let aborted = emitter._aborted || false;
+      if (aborted) return aborted;else if (old) {
+        aborted = old.aborted;
+      }
+      return aborted;
+    }
+  });
   return emitter;
   function context(contextOrStore) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore;
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ObservationContextManager.contextId, () => emitter.observationContextManager ? emitter.observationContextManager.getCreateContext(contextOrStore) : new EventContext(ObservationContextManager.contextId));
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId));
     } else {
-      return emitter.observationContextManager ? emitter.observationContextManager.getCreateContext({}) : new EventContext(ObservationContextManager.contextId);
+      return new EventContext(contextId);
     }
   }
   function emit(type, args, contextOrStore, force, bubble) {
@@ -101,11 +117,7 @@ function ee(old, debugId) {
     return handlers[type] || [];
   }
   function getOrCreate(name) {
-    const newEventEmitter = emitters[name] = emitters[name] || ee(emitter, name);
-    if (!newEventEmitter.observationContextManager && emitter.observationContextManager) {
-      newEventEmitter.observationContextManager = emitter.observationContextManager;
-    }
-    return newEventEmitter;
+    return emitters[name] = emitters[name] || ee(emitter, name);
   }
   function bufferEventsByGroup(types, group) {
     const eventBuffer = getBuffer();
@@ -131,14 +143,4 @@ function ee(old, debugId) {
   function getBuffer() {
     return emitter.backlog;
   }
-}
-function abort() {
-  globalInstance.aborted = true;
-  // The global backlog can be referenced directly by other emitters,
-  // so we need to delete its contents as opposed to replacing it.
-  // Otherwise, these references to the old backlog would still exist
-  // and the keys will not be garbage collected.
-  Object.keys(globalInstance.backlog).forEach(key => {
-    delete globalInstance.backlog[key];
-  });
 }

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

@@ -177,7 +177,9 @@ export class Harvest extends SharedContext {
         // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
         const cbResult = {
           sent: this.status !== 0,
-          status: this.status
+          status: this.status,
+          xhr: this,
+          fullUrl
         };
         if (this.status === 429) {
           cbResult.retry = true;
@@ -191,6 +193,8 @@ export class Harvest extends SharedContext {
         cbFinished(cbResult);
       }, eventListenerOpts(false));
     }
+    const runtime = getRuntime(this.sharedContext.agentIdentifier);
+    runtime.harvestCount++;
     return result;
   }
 

package/dist/esm/common/timing/time-keeper.js

@@ -0,0 +1,88 @@
+import { gosNREUM } from '../window/nreum';
+import { globalScope } from '../constants/runtime';
+import { getRuntime } from '../config/config';
+
+/**
+ * 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
+ * to the harvested data event offset time.
+ */
+export class TimeKeeper {
+  #agent;
+
+  /**
+   * Represents the browser origin time corrected to NR server time.
+   * @type {number}
+   */
+  #correctedOriginTime;
+
+  /**
+   * Represents the difference in milliseconds between the calculated NR server time and
+   * the local time.
+   * @type {number}
+   */
+  #localTimeDiff;
+  constructor(agent) {
+    this.#agent = agent;
+  }
+  static getTimeKeeperByAgentIdentifier(agentIdentifier) {
+    const nr = gosNREUM();
+    return Object.keys(nr?.initializedAgents || {}).indexOf(agentIdentifier) > -1 ? nr.initializedAgents[agentIdentifier].timeKeeper : undefined;
+  }
+  get correctedPageOriginTime() {
+    return this.#correctedOriginTime;
+  }
+
+  /**
+   * Process a rum request to calculate NR server time.
+   * @param rumRequest {XMLHttpRequest} The xhr for the rum request
+   * @param rumRequestUrl {string} The full url of the rum request
+   */
+  processRumRequest(rumRequest, rumRequestUrl) {
+    const responseDateHeader = rumRequest.getResponseHeader('Date');
+    if (!responseDateHeader) {
+      throw new Error('Missing date header on rum response.');
+    }
+    const resourceEntries = globalScope.performance.getEntriesByName(rumRequestUrl, 'resource');
+    if (!Array.isArray(resourceEntries) || resourceEntries.length === 0) {
+      throw new Error('Missing rum request performance entry.');
+    }
+    let medianRumOffset = 0;
+    let serverOffset = 0;
+    if (typeof resourceEntries[0].responseStart === 'number' && resourceEntries[0].responseStart !== 0) {
+      // Cors is enabled and we can make a more accurate calculation of NR server time
+      medianRumOffset = (resourceEntries[0].responseStart - resourceEntries[0].requestStart) / 2;
+      serverOffset = Math.floor(resourceEntries[0].requestStart + medianRumOffset);
+    } else {
+      // Cors is disabled or erred, we need to use a less accurate calculation
+      medianRumOffset = (resourceEntries[0].responseEnd - resourceEntries[0].fetchStart) / 2;
+      serverOffset = Math.floor(resourceEntries[0].fetchStart + medianRumOffset);
+    }
+
+    // Corrected page origin time
+    this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
+    this.#localTimeDiff = getRuntime(this.#agent.agentIdentifier).offset - this.#correctedOriginTime;
+    if (Number.isNaN(this.#correctedOriginTime)) {
+      throw new Error('Date header invalid format.');
+    }
+  }
+
+  /**
+   * Converts a page origin relative time to an absolute timestamp
+   * corrected to NR server time.
+   * @param relativeTime {number} The relative time of the event in milliseconds
+   * @returns {number} The correct timestamp as a unix/epoch timestamp value
+   */
+  convertRelativeTimestamp(relativeTime) {
+    return this.#correctedOriginTime + relativeTime;
+  }
+
+  /**
+   * Corrects an event timestamp to NR server time.
+   * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
+   * @return {number} Corrected unix/epoch timestamp
+   */
+  correctAbsoluteTimestamp(timestamp) {
+    return Math.floor(timestamp - this.#localTimeDiff);
+  }
+}

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

@@ -3,47 +3,30 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ee } from '../event-emitter/contextual-ee';
-import { handle } from '../event-emitter/handle';
-import { FEATURE_NAMES } from '../../loaders/features/features';
 import { dispatchGlobalEvent } from '../dispatch/global-event';
-const bucketMap = {
-  stn: [FEATURE_NAMES.sessionTrace],
-  err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
-  ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa, FEATURE_NAMES.softNav],
-  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. */
+/** A map of feature flags and their values as provided by the rum call -- scoped by agent ID */
+export const activatedFeatures = {};
+
+/**
+ * Sets the activatedFeatures object, dispatches the global loaded event,
+ * and emits the rumresp flag to features
+ * @param {{[key:string]:number}} flags key-val pair of flag names and numeric
+ * @param {string} agentIdentifier agent instance identifier
+ * @returns {void}
+ */
 export function activateFeatures(flags, agentIdentifier) {
   const sharedEE = ee.get(agentIdentifier);
+  activatedFeatures[agentIdentifier] ??= {};
   if (!(flags && typeof flags === 'object')) return;
   if (sentIds.has(agentIdentifier)) return;
-  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.
-  Object.keys(bucketMap).forEach(flag => {
-    if (activatedFeatures[flag] === undefined) {
-      bucketMap[flag]?.forEach(feat => handle('rumresp-' + flag, [false], undefined, feat, sharedEE));
-      activatedFeatures[flag] = false;
-    }
-  });
+  sharedEE.emit('rumresp', [flags]);
+  activatedFeatures[agentIdentifier] = flags;
   sentIds.add(agentIdentifier);
 
   // let any window level subscribers know that the agent is running
   dispatchGlobalEvent({
     loaded: true
   });
-}
-export const activatedFeatures = {};
+}

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

@@ -7,15 +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';
-import { ObservationContextManager } from '../context/observation-context-manager';
 const wrapped = {};
 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
@@ -44,7 +44,7 @@ export function wrapEvents(sharedEE) {
     if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {
       return;
     }
-    var wrapped = getOrSet(originalListener, ObservationContextManager.contextWrappedId, function () {
+    var wrapped = getOrSet(originalListener, flag, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

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

@@ -6,9 +6,8 @@
  * @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 { ObservationContextManager } from '../context/observation-context-manager';
 var prefix = 'fetch-';
 var bodyPrefix = prefix + 'body-';
 var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
@@ -71,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[ObservationContextManager.contextId] && ctx[ObservationContextManager.contextId].dt) dtPayload = ctx[ObservationContextManager.contextId].dt;
+        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt;
         var origPromiseFromFetch = fn.apply(this, args);
         ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);
 

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

@@ -7,7 +7,8 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee';
-import { ObservationContextManager } from '../context/observation-context-manager';
+import { bundleId } from '../ids/bundle-id';
+export const flag = "nr@original:".concat(bundleId);
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -39,7 +40,7 @@ export function createWrapperWithEmitter(emitter, always) {
    * As a property on a wrapped function, contains the original function.
    * @type {string}
    */
-  wrapFn.flag = ObservationContextManager.contextOriginalId;
+  wrapFn.flag = flag;
   return wrapFn;
 
   /**
@@ -55,7 +56,7 @@ export function createWrapperWithEmitter(emitter, always) {
     // Unless fn is both wrappable and unwrapped, return it unchanged.
     if (notWrappable(fn)) return fn;
     if (!prefix) prefix = '';
-    nrWrapper[ObservationContextManager.contextOriginalId] = fn;
+    nrWrapper[flag] = fn;
     copy(fn, nrWrapper, emitter);
     return nrWrapper;
 
@@ -209,5 +210,5 @@ function copy(from, to, emitter) {
  * @returns {boolean} Whether the passed function is ineligible to be wrapped.
  */
 function notWrappable(fn) {
-  return !(fn && typeof fn === 'function' && fn.apply && !fn[ObservationContextManager.contextOriginalId]);
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag]);
 }

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

@@ -7,10 +7,9 @@
  * This module is used by: spa.
  */
 
-import { createWrapperWithEmitter as wrapFn } from './wrap-function';
+import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function';
 import { ee as baseEE } from '../event-emitter/contextual-ee';
 import { globalScope } from '../constants/runtime';
-import { ObservationContextManager } from '../context/observation-context-manager';
 const wrapped = {};
 
 /**
@@ -119,7 +118,7 @@ export function wrapPromise(sharedEE) {
       promiseEE.emit('propagate', [originalThis, true], origFnCallWithThis, false, false);
       return origFnCallWithThis;
     };
-    prevPromiseObj.prototype.then[ObservationContextManager.contextOriginalId] = prevPromiseOrigThen;
+    prevPromiseObj.prototype.then[flag] = prevPromiseOrigThen;
     promiseEE.on('executor-start', function (args) {
       args[0] = promiseWrapper(args[0], 'resolve-', this, null, false);
       args[1] = promiseWrapper(args[1], 'resolve-', this, null, false);