@newrelic/browser-agent 1.232.1 → 1.233.0

package/dist/cjs/cdn/polyfills.js

@@ -2,8 +2,10 @@
 
 require("core-js/stable/promise");
 require("core-js/stable/array/includes");
-require("core-js/stable/array/from");
 require("core-js/stable/array/find");
+require("core-js/stable/array/flat");
+require("core-js/stable/array/flat-map");
+require("core-js/stable/array/from");
 require("core-js/stable/array/some");
 require("core-js/stable/object/assign");
 require("core-js/stable/object/entries");
@@ -11,4 +13,5 @@ require("core-js/stable/object/values");
 require("core-js/stable/map");
 require("core-js/stable/reflect");
 require("core-js/stable/set");
-require("core-js/stable/weak-set");
+require("core-js/stable/weak-set");
+require("core-js/stable/object/get-own-property-descriptors");

package/dist/cjs/common/config/state/configurable.js

@@ -3,36 +3,25 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Configurable = void 0;
-var _featureDependencies = require("../../../loaders/features/featureDependencies");
+exports.getModeledObject = getModeledObject;
 var _console = require("../../util/console");
-class Configurable {
-  constructor(obj, model) {
-    Object.assign(this, setValues(obj, model));
-  }
-}
-exports.Configurable = Configurable;
-function setValues(obj, model) {
-  const state = {};
+function getModeledObject(obj, model) {
   try {
-    if (!obj || typeof obj !== 'object') return (0, _console.warn)('New setting a Configurable requires an object as input');
+    if (!obj || typeof obj !== 'object') return (0, _console.warn)('Setting a Configurable requires an object as input');
     if (!model || typeof model !== 'object') return (0, _console.warn)('Setting a Configurable requires a model to set its initial properties');
-    Object.assign(state, model);
-    Object.entries(obj).forEach(_ref => {
-      let [key, value] = _ref;
-      if (!Object.keys(model).includes(key)) return;
-      const frozenAttrs = (0, _featureDependencies.getFrozenAttributes)(key);
-      if (frozenAttrs.length && value && typeof value === 'object') {
-        frozenAttrs.forEach(attr => {
-          if (attr in value) {
-            (0, _console.warn)("\"".concat(attr, "\" is a protected attribute and can not be changed in feature ").concat(key, ".  It will have no effect."));
-            delete value[attr];
-          }
-        });
+    // allow getters and setters to pass from model to target
+    const output = Object.create(Object.getPrototypeOf(model), Object.getOwnPropertyDescriptors(model));
+    const target = Object.keys(output).length === 0 ? obj : output;
+    for (let key in target) {
+      if (obj[key] !== undefined) {
+        try {
+          if (typeof obj[key] === 'object' && typeof model[key] === 'object') output[key] = getModeledObject(obj[key], model[key]);else output[key] = obj[key];
+        } catch (e) {
+          (0, _console.warn)('An error occurred while setting a property of a Configurable', e);
+        }
       }
-      state[key] = value;
-    });
-    return state;
+    }
+    return output;
   } catch (err) {
     (0, _console.warn)('An error occured while setting a Configurable', err);
   }

package/dist/cjs/common/config/state/info.js

@@ -45,6 +45,6 @@ function getInfo(id) {
 }
 function setInfo(id, obj) {
   if (!id) throw new Error('All info objects require an agent identifier!');
-  _cache[id] = new _configurable.Configurable(obj, model);
+  _cache[id] = (0, _configurable.getModeledObject)(obj, model);
   (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'info');
 }

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

@@ -7,63 +7,108 @@ exports.getConfiguration = getConfiguration;
 exports.getConfigurationValue = getConfigurationValue;
 exports.setConfiguration = setConfiguration;
 var _constants = require("../../session/constants");
-var _globalScope = require("../../util/global-scope");
 var _nreum = require("../../window/nreum");
 var _configurable = require("./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: _constants.DEFAULT_EXPIRES_MS,
-    inactiveMs: _constants.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
-  }
+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: _constants.DEFAULT_EXPIRES_MS,
+      inactiveMs: _constants.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: true,
+      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 = {};
 function getConfiguration(id) {
@@ -73,7 +118,7 @@ function getConfiguration(id) {
 }
 function setConfiguration(id, obj) {
   if (!id) throw new Error('All configuration objects require an agent identifier!');
-  _cache[id] = new _configurable.Configurable(obj, model);
+  _cache[id] = (0, _configurable.getModeledObject)(obj, model());
   (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'config');
 }
 function getConfigurationValue(id, path) {

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

@@ -23,6 +23,6 @@ function getLoaderConfig(id) {
 }
 function setLoaderConfig(id, obj) {
   if (!id) throw new Error('All loader-config objects require an agent identifier!');
-  _cache[id] = new _configurable.Configurable(obj, model);
+  _cache[id] = (0, _configurable.getModeledObject)(obj, model);
   (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'loader_config');
 }

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

@@ -5,13 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getRuntime = getRuntime;
 exports.setRuntime = setRuntime;
-var userAgent = _interopRequireWildcard(require("../../util/user-agent"));
 var _configurable = require("./configurable");
 var _nreum = require("../../window/nreum");
 var _globalScope = require("../../util/global-scope");
 var _env = require("../../constants/env.npm");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const model = {
   buildEnv: _env.BUILD_ENV,
   bytesSent: {},
@@ -33,7 +30,6 @@ const model = {
   releaseIds: {},
   session: undefined,
   xhrWrappable: typeof _globalScope.globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-  userAgent,
   version: _env.VERSION
 };
 const _cache = {};
@@ -44,6 +40,6 @@ function getRuntime(id) {
 }
 function setRuntime(id, obj) {
   if (!id) throw new Error('All runtime objects require an agent identifier!');
-  _cache[id] = new _configurable.Configurable(obj, model);
+  _cache[id] = (0, _configurable.getModeledObject)(obj, model);
   (0, _nreum.gosNREUMInitializedAgents)(id, _cache[id], 'runtime');
 }

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.232.1";
+const VERSION = "1.233.0";
 
 /**
  * Exposes the build type of the agent

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

@@ -12,7 +12,7 @@ exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 /**
  * Exposes the version of the agent
  */
-const VERSION = "1.232.1";
+const VERSION = "1.233.0";
 
 /**
  * Exposes the build type of the agent

package/dist/cjs/common/drain/drain.js

@@ -66,7 +66,7 @@ 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/cjs/common/harvest/harvest-scheduler.js

@@ -69,23 +69,43 @@ class HarvestScheduler extends _sharedContext.SharedContext {
   runHarvest(opts) {
     if (this.aborted) return;
     var scheduler = this;
+    let harvests = [];
+    let submitMethod;
     if (this.opts.getPayload) {
-      // Ajax & PVT
-      var submitMethod = (0, _harvest.getSubmitMethod)(this.endpoint, opts);
+      // Ajax & PVT & SR
+      submitMethod = (0, _harvest.getSubmitMethod)(this.endpoint, opts);
       if (!submitMethod) return false;
-      var retry = submitMethod.method === _submitData.submitData.xhr;
+      const retry = submitMethod.method === _submitData.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) 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,
+        includeBaseParams: this.opts.includeBaseParams,
+        customUrl: this.opts.customUrl,
+        gzip: this.opts.gzip
+      });
+    });
     if (this.started) {
       this.scheduleHarvest();
     }

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,
+      gzip,
+      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,67 @@ 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);
+    var url = customUrl || this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + '?';
+    var baseParams = includeBaseParams ? this.baseQueryString() : '';
+    var params = 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 = url + baseParams + params;
+    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 = [];
+    if (gzip) {
+      headers.push({
+        key: 'content-type',
+        value: 'application/json'
+      });
+      headers.push({
+        key: 'X-Browser-Monitoring-Key',
+        value: info.licenseKey
+      });
+      headers.push({
+        key: 'Content-Encoding',
+        value: 'gzip'
+      });
+    } else {
+      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 +218,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 +231,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 +304,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;
     }