@newrelic/browser-agent 0.0.9 → 0.1.230

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

@@ -0,0 +1,255 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWrapperWithEmitter = createWrapperWithEmitter;
+exports.flag = exports.default = void 0;
+exports.wrapFunction = wrapFunction;
+exports.wrapInPlace = wrapInPlace;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _lodash = _interopRequireDefault(require("lodash._slice"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Provides helper functions for wrapping functions in various scenarios.
+ */
+
+const flag = 'nr@original';
+
+/**
+ * A convenience alias of `hasOwnProperty`.
+ * @type {function}
+ */
+exports.flag = flag;
+var has = Object.prototype.hasOwnProperty;
+
+/**
+ * For tracking whether an event is already being emitted inside the wrapper.
+ * @type {boolean}
+ */
+var inWrapper = false;
+
+// eslint-disable-next-line
+var _default = createWrapperWithEmitter;
+/**
+ * Wraps a function in order to emit events on start, end, and error.
+ * @param {Object} [emitter] - The desired emitter for events emitted by the wrapper. Defaults to the global emitter.
+ * @param {boolean} always - If `true`, emit events even if already emitting an event.
+ * @returns {function} The wrapped function.
+ */
+exports.default = _default;
+function createWrapperWithEmitter(emitter, always) {
+  emitter || (emitter = _contextualEe.ee);
+  wrapFn.inPlace = inPlace;
+
+  /**
+   * A flag used to determine if a native function has already been wrapped.
+   * As a property on a wrapped function, contains the original function.
+   * @type {string}
+   */
+  wrapFn.flag = flag;
+  return wrapFn;
+
+  /**
+   * Wraps a function with event emitting functionality.
+   * @param {function} fn - The function to wrap.
+   * @param {string} prefix - A prefix for the names of emitted events.
+   * @param {function|object} getContext - The function or object that will serve as the 'this' context for handlers of events emitted by this wrapper.
+   * @param {string} methodName - The name of the method being wrapped.
+   * @param {boolean} bubble - If true, emitted events should also bubble up to the old emitter upon which the `emitter` in the current scope was based (if it defines one).
+   * @returns {function} The wrapped function.
+   */
+  function wrapFn(fn, prefix, getContext, methodName, bubble) {
+    // Unless fn is both wrappable and unwrapped, return it unchanged.
+    if (notWrappable(fn)) return fn;
+    if (!prefix) prefix = '';
+    nrWrapper[flag] = fn;
+    copy(fn, nrWrapper, emitter);
+    return nrWrapper;
+
+    /**
+     * A wrapper function that emits events before and after calling the wrapped function.
+     * Any arguments will be passed along to the original function.
+     * @returns {any} The return value of the wrapped function.
+     */
+    function nrWrapper() {
+      var args;
+      var originalThis;
+      var ctx;
+      var result;
+      try {
+        originalThis = this;
+        args = (0, _lodash.default)(arguments);
+        if (typeof getContext === 'function') {
+          ctx = getContext(args, originalThis);
+        } else {
+          ctx = getContext || {};
+        }
+      } catch (e) {
+        report([e, '', [args, originalThis, methodName], ctx], emitter);
+      }
+
+      // Warning: start events may mutate args!
+      safeEmit(prefix + 'start', [args, originalThis, methodName], ctx, bubble);
+      try {
+        result = fn.apply(originalThis, args);
+        return result;
+      } catch (err) {
+        safeEmit(prefix + 'err', [args, originalThis, err], ctx, bubble);
+
+        // rethrow error so we don't effect execution by observing.
+        throw err;
+      } finally {
+        // happens no matter what.
+        safeEmit(prefix + 'end', [args, originalThis, result], ctx, bubble);
+      }
+    }
+  }
+
+  /**
+   * Creates wrapper functions around each of an array of methods on a specified object.
+   * @param {Object} obj - The object to which the specified methods belong.
+   * @param {string[]} methods - An array of method names to be wrapped.
+   * @param {string} [prefix=''] - A prefix to add to the names of emitted events. If `-` is the first character, also
+   *     adds the method name before the prefix.
+   * @param {function|object} [getContext] - The function or object that will serve as the 'this' context for handlers
+   *     of events emitted by this wrapper.
+   * @param {boolean} [bubble=false] - If `true`, emitted events should also bubble up to the old emitter upon which
+   *     the `emitter` in the current scope was based (if it defines one).
+   */
+  function inPlace(obj, methods, prefix, getContext, bubble) {
+    if (!prefix) prefix = '';
+    // If prefix starts with '-' set this boolean to add the method name to the prefix before passing each one to wrap.
+    var prependMethodPrefix = prefix.charAt(0) === '-';
+    var fn;
+    var method;
+    var i;
+    for (i = 0; i < methods.length; i++) {
+      method = methods[i];
+      fn = obj[method];
+
+      // Unless fn is both wrappable and unwrapped, bail so we don't add extra properties with undefined values.
+      if (notWrappable(fn)) continue;
+      obj[method] = wrapFn(fn, prependMethodPrefix ? method + prefix : prefix, getContext, method, bubble);
+    }
+  }
+
+  /**
+   * Emits an event using the `emit` method of the `emitter` object in the executing scope, but only if an event is not
+   * already being emitted (except when the executing scope defines `always` as `true`).
+   * @param {string} evt - The name of the event to be emitted.
+   * @param {array} arr - An array of arguments to pass with the event.
+   * @param {Object} store - The function or object that will serve as the 'this'
+   *     context when applying handler functions for this event.
+   * @param {boolean} bubble - If `true`, emitted events should also
+   *     bubble up to the old emitter upon which the `emitter` in the
+   *     executing scope was based (if it defines one).
+   */
+  function safeEmit(evt, arr, store, bubble) {
+    if (inWrapper && !always) return;
+    var prev = inWrapper;
+    inWrapper = true;
+    try {
+      emitter.emit(evt, arr, store, always, bubble);
+    } catch (e) {
+      report([e, evt, arr, store], emitter);
+    }
+    inWrapper = prev;
+  }
+}
+
+/**
+ * Emits an "internal-error" event. Used to report errors encountered when emitting events using `safeEmit`.
+ * @param {array} args - Arguments to be passed to the "internal-error" event.
+ * @param {Object} [emitter] - The (optional) desired event emitter. Defaults to the global event emitter.
+ */
+function report(args, emitter) {
+  emitter || (emitter = _contextualEe.ee);
+  try {
+    emitter.emit('internal-error', args);
+  } catch (err) {
+    // do nothing
+  }
+}
+
+/**
+ * Copies properties from one object to another. Used for creating a wrapper function from an original function and for
+ * copying an original function to a property of a wrapper function named by `flag` in the executing context.
+ * @param {Object} from - The source function or object.
+ * @param {Object} to - The destination function or object.
+ * @param {Object} [emitter] - The (optional) desired event emitter if errors are encountered while copying.
+ *     Defaults to the global event emitter.
+ * @returns {object} - The destination founction or object with copied properties.
+ */
+function copy(from, to, emitter) {
+  if (Object.defineProperty && Object.keys) {
+    // Create accessors that proxy to actual function
+    try {
+      var keys = Object.keys(from);
+      // eslint-disable-next-line
+      keys.forEach(function (key) {
+        Object.defineProperty(to, key, {
+          get: function () {
+            return from[key];
+          },
+          // eslint-disable-next-line
+          set: function (val) {
+            from[key] = val;
+            return val;
+          }
+        });
+      });
+      return to;
+    } catch (e) {
+      report([e], emitter);
+    }
+  }
+  // fall back to copying properties
+  for (var i in from) {
+    if (has.call(from, i)) {
+      to[i] = from[i];
+    }
+  }
+  return to;
+}
+
+/**
+ * Determines whether a function is eligible to be wrapped in part based on whether it has already been wrapped.
+ * @param {function} fn - The function in question.
+ * @returns {boolean} Whether the passed function is ineligible to be wrapped.
+ */
+function notWrappable(fn) {
+  return !(fn && fn instanceof Function && fn.apply && !fn[flag]);
+}
+
+/**
+ * Creates a wrapped version of a function using a specified wrapper function. The new wrapped function references the
+ * original function. Also copies the properties of the original function to the wrapped function.
+ * @param {function} fn - A function to be wrapped.
+ * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
+ *     to the higher order function as an argument.
+ * @returns {function} A wrapped function with an internal reference to the original function.
+ */
+function wrapFunction(fn, wrapper) {
+  var wrapped = wrapper(fn);
+  wrapped[flag] = fn;
+  copy(fn, wrapped, _contextualEe.ee);
+  return wrapped;
+}
+
+/**
+ * Replaces a function with a wrapped version of itself. To preserve object references, rather than taking the function
+ * itself as an argument, takes the object on which the particular named function is a property.
+ * @param {Object} obj - The object on which the named function is a property.
+ * @param {string} fnName - The name of the function to be wrapped.
+ * @param {function} wrapper - A higher order function that returns a new function, which executes the function passed
+ *     to the higher order function as an argument.
+ */
+function wrapInPlace(obj, fnName, wrapper) {
+  var fn = obj[fnName];
+  obj[fnName] = wrapFunction(fn, wrapper);
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapHistory = wrapHistory;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _wrapFunction = require("./wrap-function");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps `pushState` and `replaceState` methods of `window.history` object for instrumentation.
+ * This module is used by: session_trace, spa.
+ */
+
+const wrapped = {};
+const HISTORY_FNS = ['pushState', 'replaceState'];
+
+/**
+ * Wraps the `pushState` and `replaceState` methods of `window.history` and returns a corresponding event emitter
+ * scoped to the history object.
+ * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @returns {Object} Scoped event emitter with a debug ID of `history`.
+ */
+function wrapHistory(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!_globalScope.isBrowserScope || wrapped[ee.debugId]++)
+    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
+    {
+      return ee;
+    } // then we increment the count to track # of feats using this at runtime. (History API is only avail in browser DOM context.)
+  wrapped[ee.debugId] = 1;
+  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
+  /*
+   * For objects that will be instantiated more than once, we wrap the object's prototype methods. The history object
+   * is instantiated only once, so we can wrap its methods directly--and we must wrap the history methods directly as
+   * long as [Chromium issue 783382](https://bugs.chromium.org/p/chromium/issues/detail?id=783382) remains unresolved.
+   */
+  wrapFn.inPlace(window.history, HISTORY_FNS, '-');
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `history` context. This scoping is a remnant from when all the
+ * features shared the same group in the event, to isolate events between features. It will likely be revisited.
+ * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.
+ *    Uses `ee` on the global scope if undefined).
+ * @returns {Object} Scoped event emitter with a debug ID of 'history'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('history');
+}

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapJsonP = wrapJsonP;
+var _eventListenerOpts = require("../event-listener/event-listener-opts");
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _wrapFunction = require("./wrap-function");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps DOM insertion methods which in turn wrap JSONP functions that show up in the DOM.
+ * This module is used by: spa.
+ */
+
+const wrapped = {};
+const domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild'];
+
+/**
+ * Wraps DOM insertion methods to identify script elements containing JSONP callback functions and instruments those
+ * functions with custom events in the context of a new event emitter scoped only to JSONP.
+ * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @returns {Object} Scoped event emitter with a debug ID of `jsonp`.
+ */
+function wrapJsonP(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!_globalScope.isBrowserScope || wrapped[ee.debugId])
+    // JSONP deals with DOM tags so browser window env is req'd
+    {
+      return ee;
+    }
+  wrapped[ee.debugId] = true;
+  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
+  var CALLBACK_REGEX = /[?&](?:callback|cb)=([^&#]+)/;
+  var PARENT_REGEX = /(.*)\.([^.]+)/;
+  var VALUE_REGEX = /^(\w+)(\.|$)(.*)$/;
+
+  // JSONP works by dynamically inserting <script> elements - wrap DOM methods for
+  // inserting elements to detect insertion of JSONP-specific elements.
+  wrapFn.inPlace(Node.prototype, domInsertMethods, 'dom-');
+  ee.on('dom-start', function (args) {
+    wrapElement(args[0]);
+  });
+
+  // subscribe to events on the JSONP <script> element and wrap the JSONP callback
+  // in order to track start and end of the interaction node
+  function wrapElement(el) {
+    var isScript = el && typeof el.nodeName === 'string' && el.nodeName.toLowerCase() === 'script';
+    if (!isScript) return;
+    var isValidElement = typeof el.addEventListener === 'function';
+    if (!isValidElement) return;
+    var callbackName = extractCallbackName(el.src);
+    if (!callbackName) return;
+    var callback = discoverParent(callbackName);
+    var validCallback = typeof callback.parent[callback.key] === 'function';
+    if (!validCallback) return;
+
+    // At this point we know that the element is a valid JSONP script element.
+    // The following events are emitted during the lifetime of a JSONP call:
+    // * immediately emit `new-jsonp` to notify start of the JSONP work
+    // * the wrapped callback will emit `cb-start` and `cb-end` during the execution
+    //   of the callback, here we can inspect the response
+    // * when the element emits the `load` event (script loaded and executed),
+    //   emit `jsonp-end` to notify end of the JSONP work
+    // * if the element emits the `error` event, in response emit `jsonp-error`
+    //   (and `jsonp-end`). Note that the callback in this case will likely not get
+    //   called.
+
+    var context = {};
+    wrapFn.inPlace(callback.parent, [callback.key], 'cb-', context);
+    el.addEventListener('load', onLoad, (0, _eventListenerOpts.eventListenerOpts)(false));
+    el.addEventListener('error', onError, (0, _eventListenerOpts.eventListenerOpts)(false));
+    ee.emit('new-jsonp', [el.src], context);
+    function onLoad() {
+      ee.emit('jsonp-end', [], context);
+      el.removeEventListener('load', onLoad, (0, _eventListenerOpts.eventListenerOpts)(false));
+      el.removeEventListener('error', onError, (0, _eventListenerOpts.eventListenerOpts)(false));
+    }
+    function onError() {
+      ee.emit('jsonp-error', [], context);
+      ee.emit('jsonp-end', [], context);
+      el.removeEventListener('load', onLoad, (0, _eventListenerOpts.eventListenerOpts)(false));
+      el.removeEventListener('error', onError, (0, _eventListenerOpts.eventListenerOpts)(false));
+    }
+  }
+  function extractCallbackName(src) {
+    var matches = src.match(CALLBACK_REGEX);
+    return matches ? matches[1] : null;
+  }
+  function discoverValue(longKey, obj) {
+    var matches = longKey.match(VALUE_REGEX);
+    var key = matches[1];
+    var remaining = matches[3];
+    if (!remaining) {
+      return obj[key];
+    }
+    return discoverValue(remaining, obj[key]);
+  }
+  function discoverParent(key) {
+    var matches = key.match(PARENT_REGEX);
+    if (matches && matches.length >= 3) {
+      return {
+        key: matches[2],
+        parent: discoverValue(matches[1], window)
+      };
+    }
+    return {
+      key: key,
+      parent: window
+    };
+  }
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `jsonp` context. This scoping is a remnant from when all the
+ * features shared the same group in the event, to isolate events between features. It will likely be revisited.
+ * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.
+ *     Uses `ee` on the global scope if undefined).
+ * @returns {Object} Scoped event emitter with a debug ID of 'jsonp'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('jsonp');
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapMutation = wrapMutation;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _wrapFunction = require("./wrap-function");
+var _config = require("../config/config");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps the window's DOM mutation observer for instrumentation.
+ * This module is used by: spa.
+ */
+
+const wrapped = {};
+
+/**
+ * In web environments only, wraps the `window.MutationObserver` function to emit events on start, end, and error, in
+ * the context of a new event emitter scoped only to mutations.
+ * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @returns {Object} Scoped event emitter with a debug ID of `mutation`.
+ */
+function wrapMutation(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!_globalScope.isBrowserScope || wrapped[ee.debugId])
+    // relates to the DOM tree (web env only)
+    {
+      return ee;
+    }
+  wrapped[ee.debugId] = true;
+  var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
+  var OriginalObserver = _config.originals.MO;
+  if (OriginalObserver) {
+    window.MutationObserver = function WrappedMutationObserver(cb) {
+      if (this instanceof OriginalObserver) {
+        return new OriginalObserver(wrapFn(cb, 'fn-'));
+      } else {
+        return OriginalObserver.apply(this, arguments);
+      }
+    };
+    MutationObserver.prototype = OriginalObserver.prototype;
+  }
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `mutation` context. This scoping is a remnant from when all the
+ * features shared the same group in the event, to isolate events between features. It will likely be revisited.
+ * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.
+ *     Uses `ee` on the global scope if undefined).
+ * @returns {Object} Scoped event emitter with a debug ID of 'mutation'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('mutation');
+}

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

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapPromise = wrapPromise;
+var _wrapFunction = require("./wrap-function");
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _config = require("../config/config");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps the native Promise object for instrumentation.
+ * This module is used by: spa.
+ */
+
+const wrapped = {};
+
+/**
+ * Wraps the native Promise object so that it will emit events for start, end and error in the context of a new event
+ * emitter scoped only to promise methods. Also instruments various methods, such as `all`, `race`, `resolve`,
+ * `reject`, `then`, and `catch`.
+ * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @returns {Object} Scoped event emitter with a debug ID of `promise`.
+ */
+function wrapPromise(sharedEE) {
+  const promiseEE = scopedEE(sharedEE);
+  if (wrapped[promiseEE.debugId]) {
+    return promiseEE;
+  }
+  wrapped[promiseEE.debugId] = true;
+  var getContext = _contextualEe.getOrSetContext;
+  var promiseWrapper = (0, _wrapFunction.createWrapperWithEmitter)(promiseEE);
+  var prevPromiseObj = _config.originals.PR;
+  if (prevPromiseObj) {
+    // ensure there's a Promise API (native or otherwise) to even wrap
+    wrap();
+  }
+  function wrap() {
+    _globalScope.globalScope.Promise = WrappedPromise;
+
+    // Renamed from "WrappedPromise" back to "Promise" & toString() so that we appear "native" to TP libraries...
+    Object.defineProperty(WrappedPromise, 'name', {
+      value: 'Promise'
+    });
+    WrappedPromise.toString = function () {
+      return prevPromiseObj.toString();
+    };
+
+    /**
+     * This constitutes the global used when calling "Promise.staticMethod" or chaining off a "new Promise()" object.
+     * @param {Function} executor - to be executed by the original Promise constructor
+     * @returns A new WrappedPromise object prototyped off the original.
+     */
+    function WrappedPromise(executor) {
+      var ctx = promiseEE.context();
+      var wrappedExecutor = promiseWrapper(executor, 'executor-', ctx, null, false);
+      const newCustomPromiseInst = Reflect.construct(prevPromiseObj, [wrappedExecutor], WrappedPromise); // new Promises will use WrappedPromise.prototype as theirs prototype
+
+      promiseEE.context(newCustomPromiseInst).getCtx = function () {
+        return ctx;
+      };
+      return newCustomPromiseInst;
+    }
+
+    // Make WrappedPromise inherit statics from the orig Promise.
+    Object.setPrototypeOf(WrappedPromise, prevPromiseObj);
+    ['all', 'race'].forEach(function (method) {
+      const prevStaticFn = prevPromiseObj[method];
+      WrappedPromise[method] = function (subPromises) {
+        // use our own wrapped version of "Promise.all" and ".race" static fns
+        let finalized = false;
+        subPromises?.forEach(sub => {
+          // eslint-disable-next-line
+          this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));
+        });
+        const origFnCallWithThis = prevStaticFn.apply(this, arguments);
+        return origFnCallWithThis;
+        function setNrId(overwrite) {
+          return function () {
+            promiseEE.emit('propagate', [null, !finalized], origFnCallWithThis, false, false);
+            finalized = finalized || !overwrite;
+          };
+        }
+      };
+    });
+    ['resolve', 'reject'].forEach(function (method) {
+      const prevStaticFn = prevPromiseObj[method];
+      WrappedPromise[method] = function (val) {
+        // and the same for ".resolve" and ".reject"
+        const origFnCallWithThis = prevStaticFn.apply(this, arguments);
+        if (val !== origFnCallWithThis) {
+          promiseEE.emit('propagate', [val, true], origFnCallWithThis, false, false);
+        }
+        return origFnCallWithThis;
+      };
+    });
+
+    /*
+     * Ideally, we create a new WrappedPromise.prototype chained off the original Promise's so that we don't alter it.
+     * However, there's no way to make the (native) promise returned from async functions use our WrappedPromise,
+     * so we have to modify the original prototype. This ensures that promises returned from async functions execute
+     * the same instance methods as promises created with "new Promise()", and also that instanceof async() is
+     * the global Promise (see GH issue #409). This also affects the promise returned from fetch().
+     */
+    WrappedPromise.prototype = prevPromiseObj.prototype;
+
+    // Note that this wrapping affects the same originals.PR (prototype) object.
+    const prevPromiseOrigThen = prevPromiseObj.prototype.then;
+    prevPromiseObj.prototype.then = function wrappedThen() {
+      var originalThis = this;
+      var ctx = getContext(originalThis);
+      ctx.promise = originalThis;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      args[0] = promiseWrapper(args[0], 'cb-', ctx, null, false);
+      args[1] = promiseWrapper(args[1], 'cb-', ctx, null, false);
+      const origFnCallWithThis = prevPromiseOrigThen.apply(this, args);
+      ctx.nextPromise = origFnCallWithThis;
+      promiseEE.emit('propagate', [originalThis, true], origFnCallWithThis, false, false);
+      return origFnCallWithThis;
+    };
+    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);
+    });
+    promiseEE.on('executor-err', function (args, originalThis, err) {
+      args[1](err);
+    });
+    promiseEE.on('cb-end', function (args, originalThis, result) {
+      promiseEE.emit('propagate', [result, true], this.nextPromise, false, false);
+    });
+    promiseEE.on('propagate', function (val, overwrite, trigger) {
+      if (!this.getCtx || overwrite) {
+        this.getCtx = function () {
+          // eslint-disable-next-line
+          if (val instanceof Promise) {
+            var store = promiseEE.context(val);
+          }
+          return store && store.getCtx ? store.getCtx() : this;
+        };
+      }
+    });
+  }
+  return promiseEE;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `promise` context. This scoping is a remnant from when all the
+ * features shared the same group in the event, to isolate events between features. It will likely be revisited.
+ * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.
+ *     Uses `ee` on the global scope if undefined).
+ * @returns {Object} Scoped event emitter with a debug ID of 'promise'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('promise');
+}