@newrelic/browser-agent 1.232.1 → 1.233.1

package/dist/esm/common/config/state/init.js

@@ -1,61 +1,106 @@
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS } from '../../session/constants';
-import { globalScope } from '../../util/global-scope';
 import { gosNREUMInitializedAgents } from '../../window/nreum';
-import { Configurable } from './configurable';
-const model = {
-  allow_bfcache: true,
-  // *cli - temporary feature flag for BFCache work
-  privacy: {
-    cookies_enabled: true
-  },
-  // *cli - per discussion, default should be true
-  ajax: {
-    deny_list: undefined,
-    enabled: true,
-    harvestTimeSeconds: 10
-  },
-  distributed_tracing: {
-    enabled: undefined,
-    exclude_newrelic_header: undefined,
-    cors_use_newrelic_header: undefined,
-    cors_use_tracecontext_headers: undefined,
-    allowed_origins: undefined
-  },
-  session: {
-    domain: undefined,
-    // used by first party cookies to set the top-level domain
-    expiresMs: DEFAULT_EXPIRES_MS,
-    inactiveMs: DEFAULT_INACTIVE_MS
-  },
-  ssl: undefined,
-  obfuscate: undefined,
-  jserrors: {
-    enabled: true,
-    harvestTimeSeconds: 10
-  },
-  metrics: {
-    enabled: true
-  },
-  page_action: {
-    enabled: true,
-    harvestTimeSeconds: 30
-  },
-  page_view_event: {
-    enabled: true
-  },
-  page_view_timing: {
-    enabled: true,
-    harvestTimeSeconds: 30,
-    long_task: false
-  },
-  session_trace: {
-    enabled: true,
-    harvestTimeSeconds: 10
-  },
-  spa: {
-    enabled: true,
-    harvestTimeSeconds: 10
-  }
+import { getModeledObject } from './configurable';
+const model = () => {
+  const hiddenState = {
+    blockSelector: '[data-nr-block]',
+    maskInputOptions: {
+      password: true
+    }
+  };
+  return {
+    allow_bfcache: true,
+    // *cli - temporary feature flag for BFCache work
+    privacy: {
+      cookies_enabled: true
+    },
+    // *cli - per discussion, default should be true
+    ajax: {
+      deny_list: undefined,
+      enabled: true,
+      harvestTimeSeconds: 10
+    },
+    distributed_tracing: {
+      enabled: undefined,
+      exclude_newrelic_header: undefined,
+      cors_use_newrelic_header: undefined,
+      cors_use_tracecontext_headers: undefined,
+      allowed_origins: undefined
+    },
+    session: {
+      domain: undefined,
+      // used by first party cookies to set the top-level domain
+      expiresMs: DEFAULT_EXPIRES_MS,
+      inactiveMs: DEFAULT_INACTIVE_MS
+    },
+    ssl: undefined,
+    obfuscate: undefined,
+    jserrors: {
+      enabled: true,
+      harvestTimeSeconds: 10
+    },
+    metrics: {
+      enabled: true
+    },
+    page_action: {
+      enabled: true,
+      harvestTimeSeconds: 30
+    },
+    page_view_event: {
+      enabled: true
+    },
+    page_view_timing: {
+      enabled: true,
+      harvestTimeSeconds: 30,
+      long_task: false
+    },
+    session_trace: {
+      enabled: true,
+      harvestTimeSeconds: 10
+    },
+    session_replay: {
+      // feature settings
+      enabled: false,
+      harvestTimeSeconds: 60,
+      sampleRate: 0.1,
+      errorSampleRate: 0.1,
+      // recording config settings
+      maskTextSelector: '*',
+      maskAllInputs: true,
+      // these properties only have getters because they are enforcable constants and should error if someone tries to override them
+      get blockClass() {
+        return 'nr-block';
+      },
+      get ignoreClass() {
+        return 'nr-ignore';
+      },
+      get maskTextClass() {
+        return 'nr-mask';
+      },
+      // props with a getter and setter are used to extend enforcable constants with customer input
+      // we must preserve data-nr-block no matter what else the customer sets
+      get blockSelector() {
+        return hiddenState.blockSelector;
+      },
+      set blockSelector(val) {
+        hiddenState.blockSelector += ",".concat(val);
+      },
+      // password: must always be present and true no matter what customer sets
+      get maskInputOptions() {
+        return hiddenState.maskInputOptions;
+      },
+      set maskInputOptions(val) {
+        hiddenState.maskInputOptions = {
+          ...val,
+          password: true
+        };
+      }
+    },
+    spa: {
+      enabled: true,
+      harvestTimeSeconds: 10
+    }
+  };
 };
 const _cache = {};
 export function getConfiguration(id) {
@@ -65,7 +110,7 @@ export function getConfiguration(id) {
 }
 export function setConfiguration(id, obj) {
   if (!id) throw new Error('All configuration objects require an agent identifier!');
-  _cache[id] = new Configurable(obj, model);
+  _cache[id] = getModeledObject(obj, model());
   gosNREUMInitializedAgents(id, _cache[id], 'config');
 }
 export function getConfigurationValue(id, path) {

package/dist/esm/common/config/state/loader-config.js

@@ -1,5 +1,5 @@
 import { gosNREUMInitializedAgents } from '../../window/nreum';
-import { Configurable } from './configurable';
+import { getModeledObject } from './configurable';
 const model = {
   accountID: undefined,
   trustKey: undefined,
@@ -16,6 +16,6 @@ export function getLoaderConfig(id) {
 }
 export function setLoaderConfig(id, obj) {
   if (!id) throw new Error('All loader-config objects require an agent identifier!');
-  _cache[id] = new Configurable(obj, model);
+  _cache[id] = getModeledObject(obj, model);
   gosNREUMInitializedAgents(id, _cache[id], 'loader_config');
 }

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

@@ -1,5 +1,4 @@
-import * as userAgent from '../../util/user-agent';
-import { Configurable } from './configurable';
+import { getModeledObject } from './configurable';
 import { gosNREUMInitializedAgents } from '../../window/nreum';
 import { globalScope } from '../../util/global-scope';
 import { BUILD_ENV, DIST_METHOD, VERSION } from "../../constants/env.npm";
@@ -24,7 +23,6 @@ const model = {
   releaseIds: {},
   session: undefined,
   xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-  userAgent,
   version: VERSION
 };
 const _cache = {};
@@ -35,6 +33,6 @@ export function getRuntime(id) {
 }
 export function setRuntime(id, obj) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
-  _cache[id] = new Configurable(obj, model);
+  _cache[id] = getModeledObject(obj, model);
   gosNREUMInitializedAgents(id, _cache[id], 'runtime');
 }

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.232.1";
+export const VERSION = "1.233.1";
 
 /**
  * Exposes the build type of the agent

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

@@ -6,7 +6,7 @@
 /**
  * Exposes the version of the agent
  */
-export const VERSION = "1.232.1";
+export const VERSION = "1.233.1";
 
 /**
  * Exposes the build type of the agent

package/dist/esm/common/drain/drain.js

@@ -59,7 +59,7 @@ export function drain() {
 
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
-  const items = Array.from(registry[agentIdentifier]);
+  const items = [...registry[agentIdentifier]];
   if (items.every(_ref => {
     let [key, values] = _ref;
     return values.staged;

package/dist/esm/common/harvest/harvest-scheduler.js

@@ -13,6 +13,17 @@ import { getConfigurationValue } from '../config/config';
  * Periodically invokes harvest calls and handles retries
  */
 export class HarvestScheduler extends SharedContext {
+  /**
+     * Create a HarvestScheduler
+     * @param {string} endpoint - The base BAM endpoint name -- ex. 'events'
+     * @param {object} opts - The options used to configure the HarvestScheduler
+     * @param {Function} opts.onFinished - The callback to be fired when a harvest has finished
+     * @param {Function} opts.getPayload - A callback which can be triggered to return a payload for harvesting
+     * @param {number} opts.retryDelay - The number of seconds to wait before retrying after a network failure
+     * @param {boolean} opts.raw - Use a prefabricated payload shape as the harvest payload without the need for formatting
+     * @param {string} opts.customUrl - A custom url that falls outside of the shape of the standard BAM harvester url pattern.  Will use directly instead of concatenating various pieces
+     * @param {*} parent - The parent object, whose state can be passed into SharedContext
+     */
   constructor(endpoint, opts, parent) {
     super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
     this.endpoint = endpoint;
@@ -64,23 +75,47 @@ export class HarvestScheduler extends SharedContext {
   runHarvest(opts) {
     if (this.aborted) return;
     var scheduler = this;
+    let harvests = [];
+    let submitMethod;
     if (this.opts.getPayload) {
-      // Ajax & PVT
-      var submitMethod = getSubmitMethod(this.endpoint, opts);
+      // Ajax & PVT & SR
+      submitMethod = getSubmitMethod(this.endpoint, opts);
       if (!submitMethod) return false;
-      var retry = submitMethod.method === submitData.xhr;
+      const retry = submitMethod.method === submitData.xhr;
       var payload = this.opts.getPayload({
         retry: retry
       });
-      if (payload) {
-        payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload];
-        for (var i = 0; i < payload.length; i++) {
-          this.harvest.send(this.endpoint, payload[i], opts, submitMethod, onHarvestFinished);
+      if (!payload) {
+        if (this.started) {
+          this.scheduleHarvest();
         }
+        return;
       }
+      payload = Object.prototype.toString.call(payload) === '[object Array]' ? payload : [payload];
+      harvests.push(...payload);
+    }
+
+    /** sendX is used for features that do not supply a preformatted payload via "getPayload" */
+    let send = args => this.harvest.sendX(args);
+    if (harvests.length) {
+      /** _send is the underlying method for sending in the harvest, if sending raw we can bypass the other helpers completely which format the payloads */
+      if (this.opts.raw) send = args => this.harvest._send(args);
+      /** send is used to formated the payloads from "getPayload" and obfuscate before sending */else send = args => this.harvest.send(args);
     } else {
-      this.harvest.sendX(this.endpoint, opts, onHarvestFinished);
+      // force it to run at least once in sendX mode
+      harvests.push(undefined);
     }
+    harvests.forEach(payload => {
+      send({
+        endpoint: this.endpoint,
+        payload,
+        opts,
+        submitMethod,
+        cbFinished: onHarvestFinished,
+        customUrl: this.opts.customUrl,
+        raw: this.opts.raw
+      });
+    });
     if (this.started) {
       this.scheduleHarvest();
     }

package/dist/esm/common/harvest/harvest-scheduler.test.js

@@ -0,0 +1,37 @@
+import { setConfiguration } from '../config/state/init';
+import { HarvestScheduler } from './harvest-scheduler';
+describe('runHarvest', () => {
+  it('should re-schedule harvest even if there is no accumulated data', () => {
+    setConfiguration('asdf', {});
+    const scheduler = new HarvestScheduler('events', {
+      getPayload: jest.fn()
+    }, {
+      agentIdentifier: 'asdf',
+      ee: {
+        on: jest.fn()
+      }
+    });
+    scheduler.started = true;
+    jest.spyOn(scheduler, 'scheduleHarvest');
+    scheduler.runHarvest();
+    expect(scheduler.opts.getPayload()).toBeFalsy();
+    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
+  });
+  it('should also re-schedule harvest if there is accumulated data', () => {
+    setConfiguration('asdf', {});
+    const scheduler = new HarvestScheduler('events', {
+      getPayload: jest.fn().mockImplementation(() => 'payload')
+    }, {
+      agentIdentifier: 'asdf',
+      ee: {
+        on: jest.fn()
+      }
+    });
+    scheduler.started = true;
+    scheduler.harvest._send = () => {};
+    jest.spyOn(scheduler, 'scheduleHarvest');
+    scheduler.runHarvest();
+    expect(scheduler.opts.getPayload()).toBeTruthy();
+    expect(scheduler.scheduleHarvest).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/esm/common/harvest/harvest.js

@@ -8,7 +8,7 @@ import { obj as encodeObj, param as encodeParam } from '../url/encode';
 import { stringify } from '../util/stringify';
 import { submitData } from '../util/submit-data';
 import { getLocation } from '../url/location';
-import { getInfo, getConfigurationValue, getRuntime, getConfiguration } from '../config/config';
+import { getInfo, getConfigurationValue, getRuntime } from '../config/config';
 import { cleanURL } from '../url/clean-url';
 import { now } from '../timing/now';
 import { eventListenerOpts } from '../event-listener/event-listener-opts';
@@ -17,6 +17,24 @@ import { applyFnToProps } from '../util/traverse';
 import { SharedContext } from '../context/shared-context';
 import { VERSION } from "../constants/env.npm";
 import { isBrowserScope, isWorkerScope } from '../util/global-scope';
+
+/**
+ * @typedef {object} NetworkSendSpec
+ * @param {string} endpoint The endpoint to use (jserrors, events, resources etc.)
+ * @param {object} payload Object representing payload.
+ * @param {object} payload.qs Map of values that should be sent as part of the request query string.
+ * @param {string} payload.body String that should be sent as the body of the request.
+ * @param {string} payload.body.e Special case of body used for browser interactions.
+ * @param {object} opts Additional options for sending data
+ * @param {boolean} opts.needResponse Specify whether the caller expects a response data.
+ * @param {boolean} opts.unload Specify whether the call is a final harvest during page unload.
+ * @param {boolean} opts.sendEmptyBody Specify whether the call should be made even if the body is empty. Useful for rum calls.
+ * @param {function} submitMethod The submit method to use {@link ../util/submit-data}
+ * @param {string} customUrl Override the beacon url the data is sent to; must include protocol if defined
+ * @param {boolean} gzip Enabled gzip compression on the body of the request before it is sent
+ * @param {boolean} includeBaseParams Enables the use of base query parameters in the beacon url {@see Harvest.baseQueryString}
+ */
+
 const haveSendBeacon = !!navigator.sendBeacon; // only the web window obj has sendBeacon at this time, so 'false' for other envs
 
 export class Harvest extends SharedContext {
@@ -32,62 +50,78 @@ export class Harvest extends SharedContext {
   /**
    * Initiate a harvest from multiple sources. An event that corresponds to the endpoint
    * name is emitted, which gives any listeners the opportunity to provide payload data.
-   *
-   * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
-   *
-   * @param {object} opts
-   * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
-   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
+   * @param {NetworkSendSpec} spec Specification for sending data
    */
-  sendX(endpoint, opts, cbFinished) {
+  sendX(spec) {
+    const {
+      endpoint,
+      opts
+    } = spec;
     var submitMethod = getSubmitMethod(endpoint, opts);
     if (!submitMethod) return false;
     var options = {
       retry: submitMethod.method === submitData.xhr
     };
-    return this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished) : this._send(endpoint, this.createPayload(endpoint, options), opts, submitMethod, cbFinished);
+    const payload = this.createPayload(endpoint, options);
+    var caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
+    return caller({
+      ...spec,
+      payload,
+      submitMethod
+    });
   }
 
   /**
-  * Initiate a harvest call.
-  *
-  * @param {string} endpoint - The endpoint of the harvest (jserrors, events, resources etc.)
-  * @param {object} nr - The loader singleton.
-  *
-  * @param {object} singlePayload - Object representing payload.
-  * @param {object} singlePayload.qs - Map of values that should be sent as part of the request query string.
-  * @param {string} singlePayload.body - String that should be sent as the body of the request.
-  * @param {string} singlePayload.body.e - Special case of body used for browser interactions.
-  *
-  * @param {object} opts
-  * @param {bool} opts.needResponse - Specify whether the caller expects a response data.
-  * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
-  */
-  send(endpoint, singlePayload, opts, submitMethod, cbFinished) {
-    var _this = this;
+   * Initiate a harvest call.
+   * @param {NetworkSendSpec} spec Specification for sending data
+   */
+  send(spec) {
+    const {
+      payload = {}
+    } = spec;
     var makeBody = createAccumulator();
     var makeQueryString = createAccumulator();
-    if (singlePayload.body) mapOwn(singlePayload.body, makeBody);
-    if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString);
-    var payload = {
+    if (payload.body) mapOwn(payload.body, makeBody);
+    if (payload.qs) mapOwn(payload.qs, makeQueryString);
+    var newPayload = {
       body: makeBody(),
       qs: makeQueryString()
     };
-    var caller = this.obfuscator.shouldObfuscate() ? function () {
-      return _this.obfuscateAndSend(...arguments);
-    } : function () {
-      return _this._send(...arguments);
-    };
-    return caller(endpoint, payload, opts, submitMethod, cbFinished);
+    var caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
+    return caller({
+      ...spec,
+      payload: newPayload
+    });
   }
-  obfuscateAndSend(endpoint, payload, opts, submitMethod, cbFinished) {
-    var _this2 = this;
+
+  /**
+   * Apply obfuscation rules to the payload and then initial the harvest network call.
+   * @param {NetworkSendSpec} spec Specification for sending data
+   */
+  obfuscateAndSend(spec) {
+    var _this = this;
+    const {
+      payload = {}
+    } = spec;
     applyFnToProps(payload, function () {
-      return _this2.obfuscator.obfuscateString(...arguments);
+      return _this.obfuscator.obfuscateString(...arguments);
     }, 'string', ['e']);
-    return this._send(endpoint, payload, opts, submitMethod, cbFinished);
+    return this._send({
+      ...spec,
+      payload
+    });
   }
-  _send(endpoint, payload, opts, submitMethod, cbFinished) {
+  _send(_ref) {
+    let {
+      endpoint,
+      payload = {},
+      opts = {},
+      submitMethod,
+      cbFinished,
+      customUrl,
+      raw,
+      includeBaseParams = true
+    } = _ref;
     var info = getInfo(this.sharedContext.agentIdentifier);
     if (!info.errorBeacon) return false;
     var agentRuntime = getRuntime(this.sharedContext.agentIdentifier);
@@ -100,38 +134,54 @@ export class Harvest extends SharedContext {
       }
       return false;
     }
-    if (!opts) opts = {};
-    var url = this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + this.baseQueryString();
-    if (payload.qs) url += encodeObj(payload.qs, agentRuntime.maxBytes);
+    let url = '';
+    if (customUrl) url = customUrl;else if (raw) url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint);else url = "".concat(this.getScheme(), "://").concat(info.errorBeacon, "/").concat(endpoint, "/1/").concat(info.licenseKey);
+    var baseParams = !raw && includeBaseParams ? this.baseQueryString() : '';
+    var payloadParams = payload.qs ? encodeObj(payload.qs, agentRuntime.maxBytes) : '';
     if (!submitMethod) {
       submitMethod = getSubmitMethod(endpoint, opts);
     }
     var method = submitMethod.method;
     var useBody = submitMethod.useBody;
     var body;
-    var fullUrl = url;
-    if (useBody && endpoint === 'events') {
-      body = payload.body.e;
-    } else if (useBody) {
-      body = stringify(payload.body);
-    } else {
-      fullUrl = url + encodeObj(payload.body, agentRuntime.maxBytes);
-    }
+    var fullUrl = "".concat(url, "?").concat(baseParams).concat(payloadParams);
+    const gzip = payload?.qs?.content_encoding === 'gzip';
+    if (!gzip) {
+      if (useBody && endpoint === 'events') {
+        body = payload.body.e;
+      } else if (useBody) {
+        body = stringify(payload.body);
+      } else {
+        fullUrl = fullUrl + encodeObj(payload.body, agentRuntime.maxBytes);
+      }
+    } else body = payload.body;
 
     // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
     // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
     agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.length || 0;
+    const headers = [];
+    headers.push({
+      key: 'content-type',
+      value: 'text/plain'
+    });
 
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
         we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */
-    var result = method(fullUrl, body, opts.unload && isWorkerScope);
+
+    var result = method({
+      url: fullUrl,
+      body,
+      sync: opts.unload && isWorkerScope,
+      headers
+    });
     if (cbFinished && method === submitData.xhr) {
       var xhr = result;
       xhr.addEventListener('load', function () {
         var result = {
-          sent: true
+          sent: true,
+          status: this.status
         };
         if (this.status === 429) {
           result.retry = true;
@@ -149,7 +199,9 @@ export class Harvest extends SharedContext {
     // if beacon request failed, retry with an alternative method -- will not happen for workers
     if (!result && method === submitData.beacon) {
       method = submitData.img;
-      result = method(url + encodeObj(payload.body, agentRuntime.maxBytes));
+      result = method({
+        url: fullUrl + encodeObj(payload.body, agentRuntime.maxBytes)
+      });
     }
     return result;
   }
@@ -160,9 +212,9 @@ export class Harvest extends SharedContext {
     var info = getInfo(this.sharedContext.agentIdentifier);
     var location = cleanURL(getLocation());
     var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
-    return ['?a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&ck=0',
+    return ['a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&ck=0',
     // ck param DEPRECATED - still expected by backend
-    '&s=' + (runtime.session?.value || '0'),
+    '&s=' + (runtime.session?.state.value || '0'),
     // the 0 id encaps all untrackable and default traffic
     encodeParam('ref', ref), encodeParam('ptid', runtime.ptid ? '' + runtime.ptid : '')].join('');
   }
@@ -232,7 +284,7 @@ function createAccumulator() {
   var accumulator = {};
   var hasData = false;
   return function (key, val) {
-    if (val && val.length) {
+    if (val !== null && val !== undefined && val.length) {
       accumulator[key] = val;
       hasData = true;
     }