@newrelic/browser-agent 0.0.9 → 0.1.230

package/dist/cjs/common/window/nreum.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NREUMinitialized = NREUMinitialized;
+exports.addToNREUM = addToNREUM;
+exports.defaults = void 0;
+exports.gosCDN = gosCDN;
+exports.gosNREUM = gosNREUM;
+exports.gosNREUMInfo = gosNREUMInfo;
+exports.gosNREUMInit = gosNREUMInit;
+exports.gosNREUMInitializedAgents = gosNREUMInitializedAgents;
+exports.gosNREUMLoaderConfig = gosNREUMLoaderConfig;
+exports.gosNREUMOriginals = gosNREUMOriginals;
+var _now = require("../timing/now");
+var _globalScope = require("../util/global-scope");
+const defaults = {
+  beacon: 'bam.nr-data.net',
+  errorBeacon: 'bam.nr-data.net'
+};
+exports.defaults = defaults;
+function gosNREUM() {
+  if (!_globalScope.globalScope.NREUM) {
+    _globalScope.globalScope.NREUM = {};
+  }
+  if (typeof _globalScope.globalScope.newrelic === 'undefined') _globalScope.globalScope.newrelic = _globalScope.globalScope.NREUM;
+  return _globalScope.globalScope.NREUM;
+}
+function gosNREUMInfo() {
+  let nr = gosNREUM();
+  const externallySupplied = nr.info || {};
+  nr.info = {
+    beacon: defaults.beacon,
+    errorBeacon: defaults.errorBeacon,
+    ...externallySupplied
+  };
+  return nr;
+}
+function gosNREUMLoaderConfig() {
+  let nr = gosNREUM();
+  const externallySupplied = nr.loader_config || {};
+  nr.loader_config = {
+    ...externallySupplied
+  };
+  return nr;
+}
+function gosNREUMInit() {
+  let nr = gosNREUM();
+  const externallySupplied = nr.init || {};
+  nr.init = {
+    ...externallySupplied
+  };
+  return nr;
+}
+function gosNREUMOriginals() {
+  let nr = gosNREUM();
+  if (!nr.o) {
+    nr.o = {
+      ST: _globalScope.globalScope.setTimeout,
+      SI: _globalScope.globalScope.setImmediate,
+      CT: _globalScope.globalScope.clearTimeout,
+      XHR: _globalScope.globalScope.XMLHttpRequest,
+      REQ: _globalScope.globalScope.Request,
+      EV: _globalScope.globalScope.Event,
+      PR: _globalScope.globalScope.Promise,
+      MO: _globalScope.globalScope.MutationObserver,
+      // this'll be undefined if not in a web window
+      FETCH: _globalScope.globalScope.fetch
+    };
+  }
+  return nr;
+}
+function gosNREUMInitializedAgents(id, obj, target) {
+  let nr = gosNREUM();
+  const externallySupplied = nr.initializedAgents || {};
+  const curr = externallySupplied[id] || {};
+  if (!Object.keys(curr).length) {
+    curr.initializedAt = {
+      ms: (0, _now.now)(),
+      date: new Date()
+    };
+  }
+  nr.initializedAgents = {
+    ...externallySupplied,
+    [id]: {
+      ...curr,
+      [target]: obj
+    }
+  };
+  return nr;
+}
+function addToNREUM(fnName, fn) {
+  let nr = gosNREUM();
+  nr[fnName] = fn;
+}
+function NREUMinitialized() {
+  const nr = gosNREUM();
+  nr.initialized = true;
+}
+function gosCDN() {
+  gosNREUMInfo();
+  gosNREUMInit();
+  gosNREUMOriginals();
+  gosNREUMLoaderConfig();
+  return gosNREUM();
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.subscribeToVisibilityChange = subscribeToVisibilityChange;
+var _eventListenerOpts = require("../event-listener/event-listener-opts");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @param {function} cb - called when a visibility change occurs with the vis state at that time
+ * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
+ * @returns void
+ */
+function subscribeToVisibilityChange(cb) {
+  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange);
+  return;
+  function handleVisibilityChange() {
+    if (toHiddenOnly) {
+      // trigger cb on change to hidden state only
+      if (document.visibilityState == 'hidden') cb();else return;
+    }
+    cb(document.visibilityState);
+  }
+}

package/dist/cjs/common/window/session-storage.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAllStorageItemsOfGroup = getAllStorageItemsOfGroup;
+exports.getCurrentSessionIdOrMakeNew = getCurrentSessionIdOrMakeNew;
+exports.putInBrowserStorage = putInBrowserStorage;
+exports.removeFromBrowserStorage = removeFromBrowserStorage;
+var _uniqueId = require("../ids/unique-id");
+/**
+ * Interface for Agents' usage of the Window.sessionStorage as a replacement to third-party cookies.
+ *  (All agents on a tab|window will share the same sessionStorage.)
+ *
+ * @design https://newrelic.atlassian.net/wiki/spaces/INST/pages/2522513791/JSESSIONID+Cookie+Change+Design+Document
+ * @environment Browser script
+ */
+
+const AGENT_PREFIX = 'NRBA/';
+
+/**
+ * @param {string} key
+ * @param {string} value
+ * @returns true, if item was set successfully. false, if storage is full or setItem threw an exception.
+ */
+function putInBrowserStorage(key, value) {
+  let subgroup = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  try {
+    window.sessionStorage.setItem(AGENT_PREFIX + subgroup + key, value);
+    return true;
+  } catch (ex) {
+    // Session storage may be full.
+    return false;
+  }
+}
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Storage/getItem}
+ * @param {string} key
+ */
+function getFromBrowserStorage(key) {
+  let subgroup = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return window.sessionStorage.getItem(AGENT_PREFIX + subgroup + key);
+}
+function removeFromBrowserStorage(key) {
+  let subgroup = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  try {
+    window.sessionStorage.removeItem(AGENT_PREFIX + subgroup + key);
+  } catch (e) {}
+}
+
+/**
+ * @returns {string} This tab|window's session identifier, or a new ID if not found in storage
+ */
+function getCurrentSessionIdOrMakeNew() {
+  try {
+    let sessionId;
+    if ((sessionId = getFromBrowserStorage('SESSION_ID')) === null) {
+      // Generate a new one if storage is empty (no previous ID was created or currently exists)
+      sessionId = (0, _uniqueId.generateRandomHexString)(16);
+      putInBrowserStorage('SESSION_ID', sessionId);
+    }
+    return sessionId;
+  } catch (ex) {
+    // The agent is running in a security context that does not allow access to the sessionStorage or is not in browser window context.
+    return null;
+  }
+}
+
+/**
+ * Look through the page's sessionStorage items and gather the ones that was set under some grouping label, if applicable.
+ * @param {string} [subgroup] - empty string by default, which will return all items set by browser agent
+ * @returns An object of the key-value items from putInBrowserStorage calls from agents with access to the same storage space.
+ */
+function getAllStorageItemsOfGroup() {
+  let subgroup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  const prefixFilter = AGENT_PREFIX + subgroup;
+  const groupItems = {};
+  try {
+    for (let i = 0; i < window.sessionStorage.length; i++) {
+      let key = window.sessionStorage.key(i);
+      if (!key.startsWith(prefixFilter)) continue;else key = key.slice(prefixFilter.length); // this removes the "NRBA/<subgroup>" prefix so we get back the original key putInBrowserStorage
+
+      groupItems[key] = getFromBrowserStorage(key, subgroup);
+    }
+  } catch (ex) {}
+  return groupItems;
+}

package/dist/cjs/common/window/supports-performance-observer.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.supportsPerformanceObserver = supportsPerformanceObserver;
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function supportsPerformanceObserver() {
+  return typeof _globalScope.globalScope?.PerformanceObserver === 'function';
+}

package/dist/cjs/common/wrap/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "wrapConsole", {
+  enumerable: true,
+  get: function () {
+    return _wrapConsole.wrapConsole;
+  }
+});
+Object.defineProperty(exports, "wrapEvents", {
+  enumerable: true,
+  get: function () {
+    return _wrapEvents.wrapEvents;
+  }
+});
+Object.defineProperty(exports, "wrapFetch", {
+  enumerable: true,
+  get: function () {
+    return _wrapFetch.wrapFetch;
+  }
+});
+Object.defineProperty(exports, "wrapHistory", {
+  enumerable: true,
+  get: function () {
+    return _wrapHistory.wrapHistory;
+  }
+});
+Object.defineProperty(exports, "wrapJsonP", {
+  enumerable: true,
+  get: function () {
+    return _wrapJsonp.wrapJsonP;
+  }
+});
+Object.defineProperty(exports, "wrapMutation", {
+  enumerable: true,
+  get: function () {
+    return _wrapMutation.wrapMutation;
+  }
+});
+Object.defineProperty(exports, "wrapPromise", {
+  enumerable: true,
+  get: function () {
+    return _wrapPromise.wrapPromise;
+  }
+});
+Object.defineProperty(exports, "wrapRaf", {
+  enumerable: true,
+  get: function () {
+    return _wrapRaf.wrapRaf;
+  }
+});
+Object.defineProperty(exports, "wrapTimer", {
+  enumerable: true,
+  get: function () {
+    return _wrapTimer.wrapTimer;
+  }
+});
+Object.defineProperty(exports, "wrapXhr", {
+  enumerable: true,
+  get: function () {
+    return _wrapXhr.wrapXhr;
+  }
+});
+var _wrapConsole = require("./wrap-console");
+var _wrapEvents = require("./wrap-events");
+var _wrapFetch = require("./wrap-fetch");
+var _wrapHistory = require("./wrap-history");
+var _wrapJsonp = require("./wrap-jsonp");
+var _wrapMutation = require("./wrap-mutation");
+var _wrapPromise = require("./wrap-promise");
+var _wrapRaf = require("./wrap-raf");
+var _wrapTimer = require("./wrap-timer");
+var _wrapXhr = require("./wrap-xhr");

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

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapConsole = wrapConsole;
+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 `debug`, `error`, `info`, `log`, `trace, and `warn` methods of the global `console` object for instrumentation.
+ * This module is used by: metrics.
+ */
+
+const wrapped = {};
+const CONSOLE_METHODS = ['debug', 'error', 'info', 'log', 'trace', 'warn'];
+
+/**
+ * Wraps the `debug`, `error`, `info`, `log`, `trace, and `warn` methods of global `console` object and returns a
+ * corresponding event emitter scoped to the console 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 `console`.
+ */
+function wrapConsole(sharedEE) {
+  const ee = scopedEE(sharedEE);
+
+  // We want to wrap console once and only once for each agent instance (`ee.debugId`).
+  if (wrapped[ee.debugId]) {
+    return ee;
+  }
+  wrapped[ee.debugId] = true;
+  var functionWrapper = (0, _wrapFunction.createWrapperWithEmitter)(ee);
+  // Because the console object exists once on the global scope, we don't need to wrap the prototype's methods.
+  // We use the global scope instead of window to accomodate service workers.
+  // The leading hyphen on '-console-' tells `inPlace` to prefix emitted event names with the method name too.
+  functionWrapper.inPlace(_globalScope.globalScope.console, CONSOLE_METHODS, '-console-');
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `console` 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 'console'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('console');
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapEvents = wrapEvents;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _wrapFunction = require("./wrap-function");
+var _getOrSet = require("../util/get-or-set");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps `addEventListener` and `removeEventListener` for instrumentation.
+ * 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.
+ */
+
+const wrapped = {};
+const XHR = XMLHttpRequest;
+const ADD_EVENT_LISTENER = 'addEventListener';
+const REMOVE_EVENT_LISTENER = 'removeEventListener';
+
+/**
+ * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
+ * `document` (if in a browser scope). Adds custom events in context of a new emitter scoped only to these methods.
+ * @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 `events`.
+ */
+function wrapEvents(sharedEE) {
+  var 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 = (0, _wrapFunction.createWrapperWithEmitter)(ee, true);
+
+  // Guard against instrumenting environments w/o necessary features
+  if ('getPrototypeOf' in Object) {
+    if (_globalScope.isBrowserScope) {
+      findEventListenerProtoAndCb(document, wrapNode);
+    }
+    findEventListenerProtoAndCb(_globalScope.globalScope, wrapNode);
+    findEventListenerProtoAndCb(XHR.prototype, wrapNode);
+  }
+  ee.on(ADD_EVENT_LISTENER + '-start', function (args, target) {
+    var originalListener = args[1];
+    if (originalListener === null || typeof originalListener !== 'function' && typeof originalListener !== 'object') {
+      return;
+    }
+    var wrapped = (0, _getOrSet.getOrSet)(originalListener, 'nr@wrapped', function () {
+      var listener = {
+        object: wrapHandleEvent,
+        function: originalListener
+      }[typeof originalListener];
+      return listener ? wrapFn(listener, 'fn-', null, listener.name || 'anonymous') : originalListener;
+      function wrapHandleEvent() {
+        if (typeof originalListener.handleEvent !== 'function') return;
+        return originalListener.handleEvent.apply(originalListener, arguments);
+      }
+    });
+    this.wrapped = args[1] = wrapped;
+  });
+  ee.on(REMOVE_EVENT_LISTENER + '-start', function (args) {
+    args[1] = this.wrapped || args[1];
+  });
+  function wrapNode(node) {
+    wrapFn.inPlace(node, [ADD_EVENT_LISTENER, REMOVE_EVENT_LISTENER], '-', uniqueListener);
+  }
+  function uniqueListener(args, obj) {
+    // Context for the listener is stored on itself.
+    return args[1];
+  }
+  return ee;
+}
+/**
+ * Find the base prototype of 'object' that has its own "addEventListener" property, and run some function on it.
+ * @param {Object} object - the initial object to traverse prototype chain on
+ * @param {Function} cb - the function to run on the ancestral object once found, accepts an object as a arg
+ * @param {Array} rest - [optional] any additional arguments to pass to the cb
+ */
+function findEventListenerProtoAndCb(object, cb) {
+  let step = object;
+  while (typeof step === 'object' && !Object.prototype.hasOwnProperty.call(step, ADD_EVENT_LISTENER)) {
+    step = Object.getPrototypeOf(step);
+  }
+  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    rest[_key - 2] = arguments[_key];
+  }
+  if (step) cb(step, ...rest);
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `events` 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 'events'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('events');
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapFetch = wrapFetch;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _lodash = _interopRequireDefault(require("lodash._slice"));
+var _globalScope = require("../util/global-scope");
+var _wrapFunction = require("./wrap-function");
+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 Wraps `fetch` and related methods for instrumentation.
+ * This module is used by: ajax, spa.
+ */
+
+var prefix = 'fetch-';
+var bodyPrefix = prefix + 'body-';
+var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
+var Req = _globalScope.globalScope.Request;
+var Res = _globalScope.globalScope.Response;
+var proto = 'prototype';
+var ctxId = 'nr@context';
+const wrapped = {};
+
+/**
+ * Wraps the `fetch` method of the global scope for instrumentation. Also wraps the prototypes of the async methods
+ * that parse Request and Response bodies to generate start and end events for each, in context of a new event
+ * emitter scoped only to fetch and related methods.
+ * @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 `fetch`.
+ */
+function wrapFetch(sharedEE) {
+  const ee = scopedEE(sharedEE);
+  if (!(Req && Res && _globalScope.globalScope.fetch)) {
+    return ee;
+  }
+  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;
+  bodyMethods.forEach(method => {
+    wrapPromiseMethod(Req[proto], method, bodyPrefix);
+    wrapPromiseMethod(Res[proto], method, bodyPrefix);
+  });
+  wrapPromiseMethod(_globalScope.globalScope, 'fetch', prefix);
+  ee.on(prefix + 'end', function (err, res) {
+    var ctx = this;
+    if (res) {
+      var size = res.headers.get('content-length');
+      if (size !== null) {
+        ctx.rxSize = size;
+      }
+      ee.emit(prefix + 'done', [null, res], ctx);
+    } else {
+      ee.emit(prefix + 'done', [err], ctx);
+    }
+  });
+
+  /**
+   * Wraps a Promise-returning function (referenced by `target[name]`) to emit custom events before and after
+   * execution, each decorated with metadata (arguments, payloads, errors). Used to wrap the async body
+   * parsing methods of Request and Response (e.g. `json`, `text`, `formData`).
+   * @param {Object} target - The object having the method to be wrapped.
+   * @param {string} name - The name of the method to wrap.
+   * @param {string} prefix - Used to decorate event names with context.
+   */
+  function wrapPromiseMethod(target, name, prefix) {
+    var fn = target[name];
+    if (typeof fn === 'function') {
+      target[name] = function () {
+        var args = (0, _lodash.default)(arguments);
+        var ctx = {};
+        // we are wrapping args in an array so we can preserve the reference
+        ee.emit(prefix + 'before-start', [args], ctx);
+        var dtPayload;
+        if (ctx[ctxId] && ctx[ctxId].dt) dtPayload = ctx[ctxId].dt;
+        var origPromiseFromFetch = fn.apply(this, args);
+        ee.emit(prefix + 'start', [args, dtPayload], origPromiseFromFetch);
+
+        // Note we need to cast the returned (orig) Promise from native APIs into the current global Promise, which may or may not be our WrappedPromise.
+        return origPromiseFromFetch.then(function (val) {
+          ee.emit(prefix + 'end', [null, val], origPromiseFromFetch);
+          return val;
+        }, function (err) {
+          ee.emit(prefix + 'end', [err], origPromiseFromFetch);
+          throw err;
+        });
+      };
+    }
+  }
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `fetch` 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 'fetch'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('fetch');
+}