@newrelic/browser-agent 0.0.9 → 0.1.229

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.activateFeatures = activateFeatures;
+exports.activatedFeatures = void 0;
+var _mapOwn = require("./map-own");
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _handle = require("../event-emitter/handle");
+var _drain = require("../drain/drain");
+var _features = require("../../loaders/features/features");
+/*
+ * 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]
+};
+function activateFeatures(flags, agentIdentifier) {
+  var sharedEE = _contextualEe.ee.get(agentIdentifier);
+  if (!(flags && typeof flags === 'object')) return;
+  (0, _mapOwn.mapOwn)(flags, function (flag, val) {
+    if (!val) {
+      return (bucketMap[flag] || []).forEach(feat => {
+        (0, _handle.handle)('block-' + flag, [], undefined, feat, sharedEE);
+      });
+    }
+    if (activatedFeatures[flag]) {
+      return;
+    }
+    (0, _handle.handle)('feat-' + flag, [], undefined, bucketMap[flag], sharedEE);
+    activatedFeatures[flag] = true;
+  });
+  (0, _drain.drain)(agentIdentifier, _features.FEATURE_NAMES.pageViewEvent);
+}
+const activatedFeatures = {};
+exports.activatedFeatures = activatedFeatures;

package/dist/cjs/common/util/get-or-set.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOrSet = getOrSet;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var has = Object.prototype.hasOwnProperty;
+
+// Always returns the current value of obj[prop], even if it has to set it first
+function getOrSet(obj, prop, getVal) {
+  // If the value exists return it.
+  if (has.call(obj, prop)) return obj[prop];
+  var val = getVal();
+
+  // Attempt to set the property so it's not enumerable
+  if (Object.defineProperty && Object.keys) {
+    try {
+      Object.defineProperty(obj, prop, {
+        value: val,
+        // old IE inherits non-write-ability
+        writable: true,
+        enumerable: false
+      });
+      return val;
+    } catch (e) {
+      // Can't report internal errors,
+      // because GOS is a dependency of the reporting mechanisms
+    }
+  }
+
+  // fall back to setting normally
+  obj[prop] = val;
+  return val;
+}

package/dist/cjs/common/util/global-scope.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGlobalScope = getGlobalScope;
+exports.isWorkerScope = exports.isBrowserScope = exports.globalScope = void 0;
+exports.resetScope = resetScope;
+exports.setScope = setScope;
+/* global globalThis, WorkerGlobalScope, WorkerNavigator */
+
+const isBrowserScope = Boolean(typeof window !== 'undefined' && window.document);
+exports.isBrowserScope = isBrowserScope;
+const isWorkerScope = Boolean(typeof WorkerGlobalScope !== 'undefined' && self.navigator instanceof WorkerNavigator);
+exports.isWorkerScope = isWorkerScope;
+let globalScope = (() => {
+  if (isBrowserScope) {
+    return window;
+  } else if (isWorkerScope) {
+    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
+      return globalThis;
+    } else if (self instanceof WorkerGlobalScope) {
+      return self;
+    }
+  }
+  throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".');
+})();
+
+/**
+ * The below methods are only used for testing and should be removed once the
+ * reliant tests are moved to Jest.
+ * tests/browser/protocol.browser.js
+ * tests/browser/obfuscate.browser.js
+ */
+exports.globalScope = globalScope;
+function setScope(obj) {
+  exports.globalScope = globalScope = {
+    ...obj
+  };
+}
+function resetScope() {
+  if (isBrowserScope) {
+    exports.globalScope = globalScope = window;
+  } else if (isWorkerScope) {
+    if (typeof globalThis !== 'undefined' && globalThis instanceof WorkerGlobalScope) {
+      exports.globalScope = globalScope = globalThis;
+    } else if (self instanceof WorkerGlobalScope) {
+      exports.globalScope = globalScope = self;
+    }
+  } else {
+    throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".');
+  }
+}
+function getGlobalScope() {
+  return globalScope;
+}

package/dist/cjs/common/util/map-own.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mapOwn = mapOwn;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+var has = Object.prototype.hasOwnProperty;
+function mapOwn(obj, fn) {
+  var results = [];
+  var key = '';
+  var i = 0;
+  for (key in obj) {
+    if (has.call(obj, key)) {
+      results[i] = fn(key, obj[key]);
+      i += 1;
+    }
+  }
+  return results;
+}

package/dist/cjs/common/util/obfuscate.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Obfuscator = void 0;
+exports.getRules = getRules;
+exports.validateRules = validateRules;
+var _config = require("../config/config");
+var _sharedContext = require("../context/shared-context");
+var _protocol = require("../url/protocol");
+var _console = require("./console");
+var fileProtocolRule = {
+  regex: /^file:\/\/(.*)/,
+  replacement: 'file://OBFUSCATED'
+};
+class Obfuscator extends _sharedContext.SharedContext {
+  constructor(parent) {
+    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
+  }
+
+  shouldObfuscate() {
+    return getRules(this.sharedContext.agentIdentifier).length > 0;
+  }
+
+  // applies all regex obfuscation rules to provided URL string and returns the result
+  obfuscateString(string) {
+    // if string is empty string, null or not a string, return unmodified
+    if (!string || typeof string !== 'string') return string;
+    var rules = getRules(this.sharedContext.agentIdentifier);
+    var obfuscated = string;
+
+    // apply every rule to URL string
+    for (var i = 0; i < rules.length; i++) {
+      var regex = rules[i].regex;
+      var replacement = rules[i].replacement || '*';
+      obfuscated = obfuscated.replace(regex, replacement);
+    }
+    return obfuscated;
+  }
+}
+
+// TO DO: this function should be inside the Obfuscator class since its context relates to agentID
+exports.Obfuscator = Obfuscator;
+function getRules(agentIdentifier) {
+  var rules = [];
+  var configRules = (0, _config.getConfigurationValue)(agentIdentifier, 'obfuscate') || [];
+  rules = rules.concat(configRules);
+  if (_protocol.protocol.isFileProtocol()) rules.push(fileProtocolRule);
+  // could add additional runtime/environment-specific rules here
+
+  return rules;
+}
+
+// takes array of rule objects, logs warning and returns false if any portion of rule is invalid
+function validateRules(rules) {
+  var invalidReplacementDetected = false;
+  var invalidRegexDetected = false;
+  for (var i = 0; i < rules.length; i++) {
+    if (!('regex' in rules[i])) {
+      (0, _console.warn)('An obfuscation replacement rule was detected missing a "regex" value.');
+      invalidRegexDetected = true;
+    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex.constructor === RegExp)) {
+      (0, _console.warn)('An obfuscation replacement rule contains a "regex" value with an invalid type (must be a string or RegExp)');
+      invalidRegexDetected = true;
+    }
+    var replacement = rules[i].replacement;
+    if (replacement) {
+      if (typeof replacement !== 'string') {
+        (0, _console.warn)('An obfuscation replacement rule contains a "replacement" value with an invalid type (must be a string)');
+        invalidReplacementDetected = true;
+      }
+    }
+  }
+  return !invalidReplacementDetected && !invalidRegexDetected;
+}

package/dist/cjs/common/util/reduce.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reduce = reduce;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function reduce(arr, fn, next) {
+  var i = 0;
+  if (typeof next === 'undefined') {
+    next = arr[0];
+    i = 1;
+  }
+  for (i; i < arr.length; i++) {
+    next = fn(next, arr[i]);
+  }
+  return next;
+}

package/dist/cjs/common/util/s-hash.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sHash = sHash;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+function sHash(s) {
+  var i;
+  var h = 0;
+  for (i = 0; i < s.length; i++) {
+    h += (i + 1) * s.charCodeAt(i);
+  }
+  return Math.abs(h);
+}

package/dist/cjs/common/util/single.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.single = single;
+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
+ */
+
+function single(fn) {
+  var called = false;
+  var res;
+  return function () {
+    if (called) return res;
+    called = true;
+    res = fn.apply(this, (0, _lodash.default)(arguments));
+    return res;
+  };
+}

package/dist/cjs/common/util/stringify.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringify = stringify;
+var _contextualEe = require("../event-emitter/contextual-ee");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Returns a function for use as a replacer parameter in JSON.stringify() to handle circular references.
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Cyclic_object_value MDN - Cyclical object value}
+ * @returns {Function} A function that filters out values it has seen before.
+ */
+const getCircularReplacer = () => {
+  const seen = new WeakSet();
+  return (key, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+};
+
+/**
+ * The native JSON.stringify method augmented with a replacer function to handle circular references.
+ * Circular references will be excluded from the JSON output rather than triggering errors.
+ * @param {*} val - A value to be converted to a JSON string.
+ * @returns {string} A JSON string representation of the value, with circular references handled.
+ */
+function stringify(val) {
+  try {
+    return JSON.stringify(val, getCircularReplacer());
+  } catch (e) {
+    try {
+      _contextualEe.ee.emit('internal-error', [e]);
+    } catch (err) {
+      // do nothing
+    }
+  }
+}

package/dist/cjs/common/util/submit-data.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.submitData = void 0;
+var _globalScope = require("./global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const submitData = {};
+
+/**
+ * Send via JSONP. Do NOT call this function outside of a guaranteed web window environment.
+ * @param {string} url
+ * @param {string} jsonp
+ * @returns {Element}
+ */
+exports.submitData = submitData;
+submitData.jsonp = function jsonp(url, jsonp) {
+  try {
+    if (_globalScope.isWorkerScope) {
+      try {
+        return importScripts(url + '&jsonp=' + jsonp);
+      } catch (e) {
+        // for now theres no other way to execute the callback from ingest without jsonp, or unsafe eval / new Function calls
+        // future work needs to be conducted to allow ingest to return a more traditional JSON API-like experience for the entitlement flags
+        submitData.xhrGet(url + '&jsonp=' + jsonp);
+        return false;
+      }
+    } else {
+      var element = document.createElement('script');
+      element.type = 'text/javascript';
+      element.src = url + '&jsonp=' + jsonp;
+      var firstScript = document.getElementsByTagName('script')[0];
+      firstScript.parentNode.insertBefore(element, firstScript);
+      return element;
+    }
+  } catch (err) {
+    // do nothing
+  }
+};
+submitData.xhrGet = function xhrGet(url) {
+  return submitData.xhr(url, undefined, false, 'GET');
+};
+
+/**
+ * Send via XHR
+ * @param {string} url
+ * @param {string} body
+ * @param {boolean} sync
+ * @returns {XMLHttpRequest}
+ */
+submitData.xhr = function xhr(url, body, sync, method = 'POST') {
+  var request = new XMLHttpRequest();
+  request.open(method, url, !sync);
+  try {
+    // Set cookie
+    if ('withCredentials' in request) request.withCredentials = true;
+  } catch (e) {
+    // do nothing
+  }
+  request.setRequestHeader('content-type', 'text/plain');
+  request.send(body);
+  return request;
+};
+
+/**
+ * Unused at the moment -- DEPRECATED
+ */
+// submitData.xhrSync = function xhrSync (url, body) {
+//   return submitData.xhr(url, body, true)
+// }
+
+/**
+ * Send by appending an <img> element to the page. Do NOT call this function outside of a guaranteed web window environment.
+ * @param {string} url
+ * @returns {Element}
+ */
+submitData.img = function img(url) {
+  var element = new Image();
+  element.src = url;
+  return element;
+};
+
+/**
+ * Send via sendBeacon. Do NOT call this function outside of a guaranteed web window environment.
+ * @param {string} url
+ * @param {string} body
+ * @returns {boolean}
+ */
+submitData.beacon = function (url, body) {
+  // Navigator has to be bound to ensure it does not error in some browsers
+  // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
+  const send = window.navigator.sendBeacon.bind(navigator);
+  return send(url, body);
+};

package/dist/cjs/common/util/traverse.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyFnToProps = applyFnToProps;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// traverses an object and applies a fn to property values of a certain type
+function applyFnToProps(obj, fn, type, ignoreKeys) {
+  if (!obj || typeof obj !== 'object') return obj;
+  type = type || 'string';
+  ignoreKeys = ignoreKeys || [];
+  return traverse(obj);
+  function traverse(obj) {
+    for (var property in obj) {
+      // eslint-disable-next-line
+      if (obj.hasOwnProperty(property)) {
+        if (typeof obj[property] === 'object') {
+          traverse(obj[property]);
+        } else {
+          if (typeof obj[property] === type && !shouldIgnore(property)) obj[property] = fn(obj[property]);
+        }
+      }
+    }
+    return obj;
+  }
+  function shouldIgnore(key) {
+    var ignore = false;
+    for (var i = 0; i < ignoreKeys.length; i++) {
+      if (ignoreKeys[i] === key) {
+        ignore = true;
+        break;
+      }
+    }
+    return ignore;
+  }
+}

package/dist/cjs/common/util/user-agent.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.agent = void 0;
+exports.match = match;
+exports.version = void 0;
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Feature-detection is much preferred over using User Agent to detect browser.
+// However, there are cases where feature detection is not possible, for example
+// when a specific version of a browser has a bug that requires a workaround in just
+// that version.
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#Browser_Name
+var agentName = null;
+exports.agent = agentName;
+var agentVersion = null;
+exports.version = agentVersion;
+const safari = /Version\/(\S+)\s+Safari/;
+if (navigator.userAgent) {
+  var userAgent = navigator.userAgent;
+  var parts = userAgent.match(safari);
+  if (parts && userAgent.indexOf('Chrome') === -1 && userAgent.indexOf('Chromium') === -1) {
+    exports.agent = agentName = 'Safari';
+    exports.version = agentVersion = parts[1];
+  }
+}
+function match(name, version) {
+  if (!agentName) {
+    return false;
+  }
+  if (name !== agentName) {
+    return false;
+  }
+
+  // version not provided, only match by name
+  if (!version) {
+    return true;
+  }
+
+  // version provided, but not detected - not reliable match
+  if (!agentVersion) {
+    return false;
+  }
+  var detectedParts = agentVersion.split('.');
+  var requestedParts = version.split('.');
+  for (var i = 0; i < requestedParts.length; i++) {
+    if (requestedParts[i] !== detectedParts[i]) {
+      return false;
+    }
+  }
+  return true;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onDOMContentLoaded = onDOMContentLoaded;
+exports.onWindowLoad = onWindowLoad;
+var _eventListenerOpts = require("../event-listener/event-listener-opts");
+function checkState() {
+  return typeof document === 'undefined' || document.readyState === 'complete';
+}
+function onWindowLoad(cb, useCapture) {
+  if (checkState()) return cb();
+  (0, _eventListenerOpts.windowAddEventListener)('load', cb, useCapture);
+}
+function onDOMContentLoaded(cb) {
+  if (checkState()) return cb();
+  (0, _eventListenerOpts.documentAddEventListener)('DOMContentLoaded', cb);
+}

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();
+}