@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+import { ee as globalEE } from '../event-emitter/contextual-ee';
+import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { isBrowserScope } from '../util/global-scope';
+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`.
+ */
+export function wrapHistory(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!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 = wfn(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'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || globalEE).get('history');
+}

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

@@ -0,0 +1,122 @@
+/*
+ * 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.
+ */
+
+import { eventListenerOpts } from '../event-listener/event-listener-opts';
+import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { isBrowserScope } from '../util/global-scope';
+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`.
+ */
+export function wrapJsonP(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!isBrowserScope || wrapped[ee.debugId])
+    // JSONP deals with DOM tags so browser window env is req'd
+    {
+      return ee;
+    }
+  wrapped[ee.debugId] = true;
+  var wrapFn = wfn(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, eventListenerOpts(false));
+    el.addEventListener('error', onError, eventListenerOpts(false));
+    ee.emit('new-jsonp', [el.src], context);
+    function onLoad() {
+      ee.emit('jsonp-end', [], context);
+      el.removeEventListener('load', onLoad, eventListenerOpts(false));
+      el.removeEventListener('error', onError, eventListenerOpts(false));
+    }
+    function onError() {
+      ee.emit('jsonp-error', [], context);
+      ee.emit('jsonp-end', [], context);
+      el.removeEventListener('load', onLoad, eventListenerOpts(false));
+      el.removeEventListener('error', onError, 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'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || baseEE).get('jsonp');
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
+import { originals } from '../config/config';
+import { isBrowserScope } from '../util/global-scope';
+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`.
+ */
+export function wrapMutation(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!isBrowserScope || wrapped[ee.debugId])
+    // relates to the DOM tree (web env only)
+    {
+      return ee;
+    }
+  wrapped[ee.debugId] = true;
+  var wrapFn = wfn(ee);
+  var OriginalObserver = 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'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || baseEE).get('mutation');
+}

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

@@ -0,0 +1,153 @@
+/*
+ * 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.
+ */
+
+import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function';
+import { ee as baseEE, getOrSetContext } from '../event-emitter/contextual-ee';
+import { originals } from '../config/config';
+import { globalScope } from '../util/global-scope';
+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`.
+ */
+export function wrapPromise(sharedEE) {
+  const promiseEE = scopedEE(sharedEE);
+  if (wrapped[promiseEE.debugId]) {
+    return promiseEE;
+  }
+  wrapped[promiseEE.debugId] = true;
+  var getContext = getOrSetContext;
+  var promiseWrapper = wrapFn(promiseEE);
+  var prevPromiseObj = originals.PR;
+  if (prevPromiseObj) {
+    // ensure there's a Promise API (native or otherwise) to even wrap
+    wrap();
+  }
+  function wrap() {
+    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(...args) {
+      var originalThis = this;
+      var ctx = getContext(originalThis);
+      ctx.promise = originalThis;
+      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[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'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || baseEE).get('promise');
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps `window.requestAnimationFrame` for instrumentation.
+ * This module is used by: jserror, session_trace.
+ */
+
+import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { isBrowserScope } from '../util/global-scope';
+const wrapped = {};
+const RAF_NAME = 'requestAnimationFrame';
+
+/**
+ * Wraps the `window.requestAnimationFrame` method to emit events on start, end, and error, in the context of a new
+ * event emitter ("raf") scoped only to requestAnimationFrame. Also wraps the callback passed to the method.
+ * @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 `raf`.
+ */
+export function wrapRaf(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!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. (RAF is only avail in browser DOM context.)
+  wrapped[ee.debugId] = 1;
+  var wrapFn = wfn(ee);
+  wrapFn.inPlace(window, [RAF_NAME], 'raf-');
+  ee.on('raf-start', function (args) {
+    // Wrap the callback handed to requestAnimationFrame
+    args[0] = wrapFn(args[0], 'fn-');
+  });
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `raf` 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 'raf'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || baseEE).get('raf');
+}

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps native timeout and interval methods for instrumentation.
+ * This module is used by: jserrors, session_trace, spa.
+ */
+
+import { ee as baseEE } from '../event-emitter/contextual-ee';
+import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { globalScope } from '../util/global-scope';
+const wrapped = {};
+const SET_TIMEOUT = 'setTimeout';
+const SET_INTERVAL = 'setInterval';
+const CLEAR_TIMEOUT = 'clearTimeout';
+const START = '-start';
+const DASH = '-';
+const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'clearImmediate'];
+
+/**
+ * Wraps the global `setTimeout`, `setImmediate`, `setInterval`, `clearTimeout`, and `clearImmediate` functions to emit
+ * events on start, end, and error, in the context of a new event emitter scoped only to timer functions. Also wraps
+ * the callbacks of `setTimeout` and `setInterval`.
+ * @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 `timer`.
+ */
+//eslint-disable-next-line
+export function wrapTimer(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (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.
+  wrapped[ee.debugId] = 1;
+  var wrapFn = wfn(ee);
+  wrapFn.inPlace(globalScope, TIMER_FNS.slice(0, 2), SET_TIMEOUT + DASH);
+  wrapFn.inPlace(globalScope, TIMER_FNS.slice(2, 3), SET_INTERVAL + DASH);
+  wrapFn.inPlace(globalScope, TIMER_FNS.slice(3), CLEAR_TIMEOUT + DASH);
+  ee.on(SET_INTERVAL + START, interval);
+  ee.on(SET_TIMEOUT + START, timer);
+  function interval(args, obj, type) {
+    args[0] = wrapFn(args[0], 'fn-', null, type);
+  }
+  function timer(args, obj, type) {
+    this.method = type;
+    this.timerDuration = isNaN(args[1]) ? 0 : +args[1];
+    args[0] = wrapFn(args[0], 'fn-', this, type);
+  }
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `timer` 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 'timer'.
+ */
+export function scopedEE(sharedEE) {
+  return (sharedEE || baseEE).get('timer');
+}