@newrelic/browser-agent 1.253.0 → 1.254.1

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.254.1](https://github.com/newrelic/newrelic-browser-agent/compare/v1.254.0...v1.254.1) (2024-03-26)
+
+
+### Bug Fixes
+
+* Server Timing - Remove reliance on performance API ([#930](https://github.com/newrelic/newrelic-browser-agent/issues/930)) ([250efcd](https://github.com/newrelic/newrelic-browser-agent/commit/250efcd3bf0a730adbb9d5c45be0bf2f71189664))
+
+## [1.254.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.253.0...v1.254.0) (2024-03-25)
+
+
+### Features
+
+* Add rum-response metadata handler ([#913](https://github.com/newrelic/newrelic-browser-agent/issues/913)) ([2c99a5b](https://github.com/newrelic/newrelic-browser-agent/commit/2c99a5b11300ea9ef9ee7b5158b9d42c00693d03))
+* Calculate New Relic time in the agent ([#911](https://github.com/newrelic/newrelic-browser-agent/issues/911)) ([91b1f96](https://github.com/newrelic/newrelic-browser-agent/commit/91b1f96efafe19f7b1b3fd4f39b9af1136b0a3a8))
+* maintain a harvestCount for use later with harvestId ([#922](https://github.com/newrelic/newrelic-browser-agent/issues/922)) ([d0b5b7d](https://github.com/newrelic/newrelic-browser-agent/commit/d0b5b7d644b8ffc3667bf3b2521733cc7940f982))
+* Standardize all feature behavior to wait for RUM response ([#927](https://github.com/newrelic/newrelic-browser-agent/issues/927)) ([ac266fa](https://github.com/newrelic/newrelic-browser-agent/commit/ac266faea203a7edc01ddecabbfdcc13bf602081))
+
+
+### Bug Fixes
+
+* Remove webpack imports in npm package ([#925](https://github.com/newrelic/newrelic-browser-agent/issues/925)) ([7b35238](https://github.com/newrelic/newrelic-browser-agent/commit/7b35238d53df97ca0183f06642601eb381aad063))
+
 ## [1.253.0](https://github.com/newrelic/newrelic-browser-agent/compare/v1.252.1...v1.253.0) (2024-03-13)
 
 

package/README.md

@@ -259,7 +259,7 @@ For more details on how best to contribute, see [CONTRIBUTING.md](CONTRIBUTING.m
 
 As noted in our [security policy](https://github.com/newrelic/newrelic-browser-agent/security/policy), New Relic is committed to the privacy and security of our customers and their data. We believe that providing coordinated disclosure by security researchers and engaging with the security community are important means to achieve our security goals.
 
-If you believe you have found a security vulnerability in this project or any of New Relic's products or websites, we welcome and greatly appreciate you reporting it to New Relic through [HackerOne](https://hackerone.com/newrelic).
+If you believe you have found a security vulnerability in this project or any of New Relic's products or websites, we welcome and greatly appreciate you reporting it to New Relic through [our bug bounty program](https://docs.newrelic.com/docs/security/security-privacy/information-security/report-security-vulnerabilities/).
 
 If you would like to contribute to this project, review [these guidelines](./CONTRIBUTING.md).
 

package/dist/cjs/cdn/polyfills.js

@@ -18,4 +18,5 @@ require("core-js/stable/weak-set");
 require("core-js/stable/object/get-own-property-descriptors");
 require("core-js/stable/url");
 require("core-js/stable/url-search-params");
-require("core-js/stable/string/starts-with");
+require("core-js/stable/string/starts-with");
+require("core-js/stable/number/is-nan");

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

@@ -24,10 +24,13 @@ const model = {
   origin: '' + _runtime.globalScope.location,
   ptid: undefined,
   releaseIds: {},
+  /** Agent-specific metadata found in the RUM call response. ex. entityGuid */
+  appMetadata: {},
   session: undefined,
   xhrWrappable: typeof _runtime.globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
   version: _env.VERSION,
-  denyList: undefined
+  denyList: undefined,
+  harvestCount: 0
 };
 const _cache = {};
 function getRuntime(id) {

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.253.0";
+const VERSION = exports.VERSION = "1.254.1";
 
 /**
  * Exposes the build type of the agent

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.RRWEB_VERSION = exports.DIST_METHOD = exports.BUILD_EN
 /**
  * Exposes the version of the agent
  */
-const VERSION = exports.VERSION = "1.253.0";
+const VERSION = exports.VERSION = "1.254.1";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/drain/drain.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.deregisterDrain = deregisterDrain;
 exports.drain = drain;
 exports.registerDrain = registerDrain;
 var _contextualEe = require("../event-emitter/contextual-ee");
@@ -35,13 +36,24 @@ 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
+ */
+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();
 }
 
@@ -60,11 +72,15 @@ 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]];
@@ -76,40 +92,38 @@ 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 ? _contextualEe.ee.get(agentIdentifier) : _contextualEe.ee;
-    const handlers = _registerHandler.registerHandler.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);
-      }
-      (0, _mapOwn.mapOwn)(groupHandlers, function (eventType, handlerRegistrationList) {
-        (0, _mapOwn.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 ? _contextualEe.ee.get(agentIdentifier) : _contextualEe.ee;
+  const handlers = _registerHandler.registerHandler.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, []);
+    (0, _mapOwn.mapOwn)(groupHandlers, function (eventType, handlerRegistrationList) {
+      (0, _mapOwn.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/cjs/common/event-emitter/contextual-ee.js

@@ -3,17 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ee = void 0;
+exports.ee = exports.contextId = void 0;
 var _nreum = require("../window/nreum");
 var _getOrSet = require("../util/get-or-set");
 var _config = require("../config/config");
-var _eventContext = require("../context/event-context");
-var _observationContextManager = require("../context/observation-context-manager");
+var _eventContext = require("./event-context");
+var _bundleId = require("../ids/bundle-id");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
+// create a unique id to store event context data for the current agent bundle
+const contextId = exports.contextId = "nr@context:".concat(_bundleId.bundleId);
 // create global emitter instance that can be shared among bundles
 const globalInstance = exports.ee = ee(undefined, 'globalEE');
 
@@ -48,20 +50,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.EventContext) {
       return contextOrStore;
     } else if (contextOrStore) {
-      return (0, _getOrSet.getOrSet)(contextOrStore, _observationContextManager.ObservationContextManager.contextId, () => emitter.observationContextManager ? emitter.observationContextManager.getCreateContext(contextOrStore) : new _eventContext.EventContext(_observationContextManager.ObservationContextManager.contextId));
+      return (0, _getOrSet.getOrSet)(contextOrStore, contextId, () => new _eventContext.EventContext(contextId));
     } else {
-      return emitter.observationContextManager ? emitter.observationContextManager.getCreateContext({}) : new _eventContext.EventContext(_observationContextManager.ObservationContextManager.contextId);
+      return new _eventContext.EventContext(contextId);
     }
   }
   function emit(type, args, contextOrStore, force, bubble) {
@@ -105,11 +121,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();
@@ -135,14 +147,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/cjs/common/harvest/harvest.js

@@ -185,7 +185,9 @@ class Harvest extends _sharedContext.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;
@@ -199,6 +201,8 @@ class Harvest extends _sharedContext.SharedContext {
         cbFinished(cbResult);
       }, (0, _eventListenerOpts.eventListenerOpts)(false));
     }
+    const runtime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
+    runtime.harvestCount++;
     return result;
   }
 

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

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimeKeeper = void 0;
+var _nreum = require("../window/nreum");
+var _config = require("../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.
+ */
+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 = (0, _nreum.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 startTime {number} The start time of the RUM request
+   * @param endTime {number} The end time of the RUM request
+   */
+  processRumRequest(rumRequest, startTime, endTime) {
+    const responseDateHeader = rumRequest.getResponseHeader('Date');
+    if (!responseDateHeader) {
+      throw new Error('Missing date header on rum response.');
+    }
+    const medianRumOffset = (endTime - startTime) / 2;
+    const serverOffset = Math.floor(startTime + medianRumOffset);
+
+    // Corrected page origin time
+    this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset);
+    this.#localTimeDiff = (0, _config.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);
+  }
+
+  /**
+   * Returns the current time offset from page origin.
+   * @return {number}
+   */
+  now() {
+    return Math.floor(performance.now());
+  }
+}
+exports.TimeKeeper = TimeKeeper;

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

@@ -6,52 +6,35 @@ Object.defineProperty(exports, "__esModule", {
 exports.activateFeatures = activateFeatures;
 exports.activatedFeatures = void 0;
 var _contextualEe = require("../event-emitter/contextual-ee");
-var _handle = require("../event-emitter/handle");
-var _features = require("../../loaders/features/features");
 var _globalEvent = require("../dispatch/global-event");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const bucketMap = {
-  stn: [_features.FEATURE_NAMES.sessionTrace],
-  err: [_features.FEATURE_NAMES.jserrors, _features.FEATURE_NAMES.metrics],
-  ins: [_features.FEATURE_NAMES.pageAction],
-  spa: [_features.FEATURE_NAMES.spa, _features.FEATURE_NAMES.softNav],
-  sr: [_features.FEATURE_NAMES.sessionReplay, _features.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 */
+const activatedFeatures = exports.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}
+ */
 function activateFeatures(flags, agentIdentifier) {
   const sharedEE = _contextualEe.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) (0, _handle.handle)('block-' + flag, [], undefined, feat, sharedEE);else (0, _handle.handle)('feat-' + flag, [], undefined, feat, sharedEE);
-        (0, _handle.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) (0, _handle.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 => (0, _handle.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
   (0, _globalEvent.dispatchGlobalEvent)({
     loaded: true
   });
-}
-const activatedFeatures = exports.activatedFeatures = {};
+}

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

@@ -9,7 +9,6 @@ var _contextualEe = require("../event-emitter/contextual-ee");
 var _wrapFunction = require("./wrap-function");
 var _getOrSet = require("../util/get-or-set");
 var _runtime = require("../constants/runtime");
-var _observationContextManager = require("../context/observation-context-manager");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -24,6 +23,7 @@ const wrapped = {};
 const XHR = _runtime.globalScope.XMLHttpRequest;
 const ADD_EVENT_LISTENER = 'addEventListener';
 const REMOVE_EVENT_LISTENER = 'removeEventListener';
+const flag = "nr@wrapped:".concat(_contextualEe.contextId);
 
 /**
  * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
@@ -52,7 +52,7 @@ function wrapEvents(sharedEE) {
     if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {
       return;
     }
-    var wrapped = (0, _getOrSet.getOrSet)(originalListener, _observationContextManager.ObservationContextManager.contextWrappedId, function () {
+    var wrapped = (0, _getOrSet.getOrSet)(originalListener, flag, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

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

@@ -7,7 +7,6 @@ exports.scopedEE = scopedEE;
 exports.wrapFetch = wrapFetch;
 var _contextualEe = require("../event-emitter/contextual-ee");
 var _runtime = require("../constants/runtime");
-var _observationContextManager = require("../context/observation-context-manager");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -79,7 +78,7 @@ 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.ObservationContextManager.contextId] && ctx[_observationContextManager.ObservationContextManager.contextId].dt) dtPayload = ctx[_observationContextManager.ObservationContextManager.contextId].dt;
+        if (ctx[_contextualEe.contextId] && ctx[_contextualEe.contextId].dt) dtPayload = ctx[_contextualEe.contextId].dt;
         var origPromiseFromFetch = fn.apply(this, args);
         ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);
 

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

@@ -4,9 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createWrapperWithEmitter = createWrapperWithEmitter;
-exports.default = void 0;
+exports.flag = exports.default = void 0;
 var _contextualEe = require("../event-emitter/contextual-ee");
-var _observationContextManager = require("../context/observation-context-manager");
+var _bundleId = require("../ids/bundle-id");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -15,6 +15,8 @@ var _observationContextManager = require("../context/observation-context-manager
  * @file Provides helper functions for wrapping functions in various scenarios.
  */
 
+const flag = exports.flag = "nr@original:".concat(_bundleId.bundleId);
+
 /**
  * A convenience alias of `hasOwnProperty`.
  * @type {function}
@@ -44,7 +46,7 @@ function createWrapperWithEmitter(emitter, always) {
    * As a property on a wrapped function, contains the original function.
    * @type {string}
    */
-  wrapFn.flag = _observationContextManager.ObservationContextManager.contextOriginalId;
+  wrapFn.flag = flag;
   return wrapFn;
 
   /**
@@ -60,7 +62,7 @@ function createWrapperWithEmitter(emitter, always) {
     // Unless fn is both wrappable and unwrapped, return it unchanged.
     if (notWrappable(fn)) return fn;
     if (!prefix) prefix = '';
-    nrWrapper[_observationContextManager.ObservationContextManager.contextOriginalId] = fn;
+    nrWrapper[flag] = fn;
     copy(fn, nrWrapper, emitter);
     return nrWrapper;
 
@@ -214,5 +216,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.ObservationContextManager.contextOriginalId]);
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag]);
 }

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

@@ -8,7 +8,6 @@ exports.wrapPromise = wrapPromise;
 var _wrapFunction = require("./wrap-function");
 var _contextualEe = require("../event-emitter/contextual-ee");
 var _runtime = require("../constants/runtime");
-var _observationContextManager = require("../context/observation-context-manager");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
@@ -126,7 +125,7 @@ function wrapPromise(sharedEE) {
       promiseEE.emit('propagate', [originalThis, true], origFnCallWithThis, false, false);
       return origFnCallWithThis;
     };
-    prevPromiseObj.prototype.then[_observationContextManager.ObservationContextManager.contextOriginalId] = prevPromiseOrigThen;
+    prevPromiseObj.prototype.then[_wrapFunction.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);

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

@@ -27,12 +27,15 @@ class Aggregate extends _aggregateBase.AggregateBase {
   constructor(agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME);
     const agentInit = (0, _config.getConfiguration)(agentIdentifier);
-    const allAjaxIsEnabled = agentInit.ajax.enabled !== false;
     (0, _registerHandler.registerHandler)('xhr', storeXhr, this.featureName, this.ee);
-    if (!allAjaxIsEnabled) {
+    this.waitForFlags([]).then(() => {
+      const scheduler = new _harvestScheduler.HarvestScheduler('events', {
+        onFinished: onEventsHarvestFinished,
+        getPayload: prepareHarvest
+      }, this);
+      scheduler.startTimer(harvestTimeSeconds);
       this.drain();
-      return; // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
-    }
+    });
     const denyList = (0, _config.getRuntime)(agentIdentifier).denyList;
     (0, _denyList.setDenyList)(denyList);
     let ajaxEvents = [];
@@ -68,14 +71,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
     (0, _registerHandler.registerHandler)('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee);
     // --- ^
 
-    const scheduler = new _harvestScheduler.HarvestScheduler('events', {
-      onFinished: onEventsHarvestFinished,
-      getPayload: prepareHarvest
-    }, this);
-    ee.on("drain-".concat(this.featureName), () => {
-      scheduler.startTimer(harvestTimeSeconds);
-    });
-    this.drain();
     const beacon = (0, _config.getInfo)(agentIdentifier).errorBeacon;
     const proxyBeacon = agentInit.proxy.beacon;
     function storeXhr(params, metrics, startTime, endTime, type) {
@@ -95,7 +90,6 @@ class Aggregate extends _aggregateBase.AggregateBase {
       if (shouldCollect || !ajaxMetricDenyListEnabled) {
         aggregator.store('xhr', hash, params, metrics);
       }
-      if (!allAjaxIsEnabled) return;
       if (!shouldCollect) {
         if (params.hostname === beacon || proxyBeacon && params.hostname === proxyBeacon) {
           // This doesn't make a distinction if the same-domain request is going to a different port or path...