@newrelic/browser-agent 1.232.1 → 1.233.1

package/dist/cjs/common/harvest/harvest.js

@@ -24,6 +24,23 @@ var _globalScope = require("../util/global-scope");
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * @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
 
 class Harvest extends _sharedContext.SharedContext {
@@ -39,62 +56,78 @@ class Harvest extends _sharedContext.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.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) (0, _mapOwn.mapOwn)(singlePayload.body, makeBody);
-    if (singlePayload.qs) (0, _mapOwn.mapOwn)(singlePayload.qs, makeQueryString);
-    var payload = {
+    if (payload.body) (0, _mapOwn.mapOwn)(payload.body, makeBody);
+    if (payload.qs) (0, _mapOwn.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;
     (0, _traverse.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 = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     if (!info.errorBeacon) return false;
     var agentRuntime = (0, _config.getRuntime)(this.sharedContext.agentIdentifier);
@@ -107,38 +140,54 @@ class Harvest extends _sharedContext.SharedContext {
       }
       return false;
     }
-    if (!opts) opts = {};
-    var url = this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + this.baseQueryString();
-    if (payload.qs) url += (0, _encode.obj)(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 ? (0, _encode.obj)(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 = (0, _stringify.stringify)(payload.body);
-    } else {
-      fullUrl = url + (0, _encode.obj)(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 = (0, _stringify.stringify)(payload.body);
+      } else {
+        fullUrl = fullUrl + (0, _encode.obj)(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 && _globalScope.isWorkerScope);
+
+    var result = method({
+      url: fullUrl,
+      body,
+      sync: opts.unload && _globalScope.isWorkerScope,
+      headers
+    });
     if (cbFinished && method === _submitData.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;
@@ -156,7 +205,9 @@ class Harvest extends _sharedContext.SharedContext {
     // if beacon request failed, retry with an alternative method -- will not happen for workers
     if (!result && method === _submitData.submitData.beacon) {
       method = _submitData.submitData.img;
-      result = method(url + (0, _encode.obj)(payload.body, agentRuntime.maxBytes));
+      result = method({
+        url: fullUrl + (0, _encode.obj)(payload.body, agentRuntime.maxBytes)
+      });
     }
     return result;
   }
@@ -167,9 +218,9 @@ class Harvest extends _sharedContext.SharedContext {
     var info = (0, _config.getInfo)(this.sharedContext.agentIdentifier);
     var location = (0, _cleanUrl.cleanURL)((0, _location.getLocation)());
     var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
-    return ['?a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.now)(), '&ck=0',
+    return ['a=' + info.applicationID, (0, _encode.param)('sa', info.sa ? '' + info.sa : ''), (0, _encode.param)('v', _env.VERSION), transactionNameParam(info), (0, _encode.param)('ct', runtime.customTransaction), '&rst=' + (0, _now.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
     (0, _encode.param)('ref', ref), (0, _encode.param)('ptid', runtime.ptid ? '' + runtime.ptid : '')].join('');
   }
@@ -240,7 +291,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;
     }

package/dist/cjs/common/session/session-entity.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SessionEntity = void 0;
+exports.SessionEntity = exports.SESSION_EVENTS = void 0;
 var _uniqueId = require("../ids/unique-id");
 var _console = require("../util/console");
 var _stringify = require("../util/stringify");
@@ -18,15 +18,23 @@ var _configurable = require("../config/state/configurable");
 var _handle = require("../event-emitter/handle");
 var _constants2 = require("../../features/metrics/constants");
 var _features = require("../../loaders/features/features");
+// this is what can be stored in local storage (not enforced but probably should be)
+// these values should sync between local storage and the parent class props
 const model = {
   value: '',
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplayActive: false,
+  sessionReplay: 0,
   sessionTraceActive: false,
   custom: {}
 };
+const SESSION_EVENTS = {
+  PAUSE: 'session-pause',
+  RESET: 'session-reset',
+  RESUME: 'session-resume'
+};
+exports.SESSION_EVENTS = SESSION_EVENTS;
 class SessionEntity {
   /**
    * Create a self-managing Session Entity. This entity is scoped to the agent identifier which triggered it, allowing for multiple simultaneous session objects to exist.
@@ -48,13 +56,13 @@ class SessionEntity {
     } = _ref;
     if (!agentIdentifier || !key) throw new Error('Missing Required Fields');
     if (!_globalScope.isBrowserScope) this.storage = new _localMemory.LocalMemory();else this.storage = storageAPI;
+    this.state = {};
     this.sync(model);
     this.agentIdentifier = agentIdentifier;
-
     // key is intended to act as the k=v pair
     this.key = key;
     // value is intended to act as the primary value of the k=v pair
-    this.value = value;
+    this.state.value = value;
     this.expiresMs = expiresMs;
     this.inactiveMs = inactiveMs;
     this.ee = _contextualEe.ee.get(agentIdentifier);
@@ -71,7 +79,7 @@ class SessionEntity {
     // the set-up of the timer used to expire the session "naturally" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     if (expiresMs) {
-      this.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
+      this.state.expiresAt = initialRead?.expiresAt || this.getFutureTimestamp(expiresMs);
       this.expiresTimer = new _timer.Timer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -79,16 +87,16 @@ class SessionEntity {
           this.collectSM('duration', this);
           this.reset();
         }
-      }, this.expiresAt - Date.now());
+      }, this.state.expiresAt - Date.now());
     } else {
-      this.expiresAt = Infinity;
+      this.state.expiresAt = Infinity;
     }
 
     // the set-up of the timer used to expire the session due to "inactivity" at a certain time
     // this gets ignored if the value is falsy, allowing for session entities that do not expire
     // this gets "refreshed" when "activity" is observed
     if (inactiveMs) {
-      this.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
+      this.state.inactiveAt = initialRead?.inactiveAt || this.getFutureTimestamp(inactiveMs);
       this.inactiveTimer = new _interactionTimer.InteractionTimer({
         // When the inactive timer ends, collect a SM and reset the session
         onEnd: () => {
@@ -98,21 +106,27 @@ class SessionEntity {
         },
         // When the inactive timer refreshes, it will update the storage values with an update timestamp
         onRefresh: this.refresh.bind(this),
+        onResume: () => {
+          this.ee.emit(SESSION_EVENTS.RESUME);
+        },
         // When the inactive timer pauses, update the storage values with an update timestamp
-        onPause: () => this.write(new _configurable.Configurable(this.read(), model)),
+        onPause: () => {
+          if (this.initialized) this.ee.emit(SESSION_EVENTS.PAUSE);
+          this.write((0, _configurable.getModeledObject)(this.state, model));
+        },
         ee: this.ee,
         refreshEvents: ['click', 'keydown', 'scroll']
-      }, this.inactiveAt - Date.now());
+      }, this.state.inactiveAt - Date.now());
     } else {
-      this.inactiveAt = Infinity;
+      this.state.inactiveAt = Infinity;
     }
 
     // The fact that the session is "new" or pre-existing is used in some places in the agent.  Session Replay and Trace
     // can use this info to inform whether to trust a new sampling decision vs continue a previous tracking effort.
-    this.isNew = !Object.keys(initialRead).length;
+    if (this.isNew === undefined) this.isNew = !Object.keys(initialRead).length;
     // if its a "new" session, we write to storage API with the default values.  These values may change over the lifespan of the agent run.
-    // we can use configurable here to help us know and manage what values are being used. -- see "model" above
-    if (this.isNew) this.write(new _configurable.Configurable(this, model), true);else this.sync(initialRead);
+    // we can use a modeled object here to help us know and manage what values are being used. -- see "model" above
+    if (this.isNew) this.write((0, _configurable.getModeledObject)(this.state, model), true);else this.sync(initialRead);
     this.initialized = true;
   }
 
@@ -121,7 +135,7 @@ class SessionEntity {
     return "".concat(_constants.PREFIX, "_").concat(this.key);
   }
   sync(data) {
-    Object.assign(this, data);
+    Object.assign(this.state, data);
   }
 
   /**
@@ -168,7 +182,8 @@ class SessionEntity {
       if (!data || typeof data !== 'object') return;
       // everytime we update, we can update a timestamp for sanity
       data.updatedAt = Date.now();
-      this.sync(data);
+      this.sync(data); // update the parent class "state" properties with the local storage values
+      //
       // TODO - compression would need happen here if we decide to do it
       this.storage.set(this.lookupKey, (0, _stringify.stringify)(data));
       return data;
@@ -184,12 +199,11 @@ class SessionEntity {
     // * stop recording (stn and sr)...
     // * delete the session and start over
     try {
-      if (this.initialized) this.ee.emit('session-reset');
+      if (this.initialized) this.ee.emit(SESSION_EVENTS.RESET);
       this.storage.remove(this.lookupKey);
       this.inactiveTimer?.abort?.();
       this.expiresTimer?.clear?.();
-      delete this.custom;
-      delete this.value;
+      delete this.isNew;
       this.setup({
         agentIdentifier: this.agentIdentifier,
         key: this.key,
@@ -209,10 +223,9 @@ class SessionEntity {
   refresh() {
     // read here & invalidate
     const existingData = this.read();
-    this.inactiveAt = this.getFutureTimestamp(this.inactiveMs);
     this.write({
       ...existingData,
-      inactiveAt: this.inactiveAt
+      inactiveAt: this.getFutureTimestamp(this.inactiveMs)
     });
   }
 
@@ -229,7 +242,7 @@ class SessionEntity {
    * @returns {boolean}
    */
   isInvalid(data) {
-    const requiredKeys = ['value', 'expiresAt', 'inactiveAt'];
+    const requiredKeys = Object.keys(model);
     return !requiredKeys.every(x => Object.keys(data).includes(x));
   }
   collectSM(type, data, useUpdatedAt) {