@newrelic/browser-agent 1.232.1 → 1.233.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.232.1",
+  "version": "1.233.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "Tests for the New Relic JavaScript agent",
@@ -87,16 +87,17 @@
     "node": ">=12.17.0 < 13.0.0 || >=13.7.0"
   },
   "scripts": {
-    "wdio": "node tools/wdio/bin/cli.js",
+    "wdio": "node --max-old-space-size=8192 tools/wdio/bin/cli.js",
     "start": "npm-run-all --parallel cdn:watch test-server",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "build:all": "npm run cdn:build:local && npm run build:npm && npm run tools:test-builds",
     "build:npm": "npm run npm:build:esm && npm run npm:build:cjs && npm run npm:build:types && npm run npm:pack",
+    "build:browser-tests": "npm --prefix ./tools/test-builds/browser-tests run build",
     "lint": "eslint -c .eslintrc.js --ext .js,.cjs,.mjs .",
     "lint:fix": "npm run lint -- --fix",
-    "test-all": "tools/jil/bin/cli.js -b *@*",
+    "test-jil": "tools/jil/bin/cli.js",
     "ci-build": "npm ci --cache ./.npm",
     "build-tar": "npm run ci-build && tar czf ./build/browser-agent.tar.gz --exclude=.git --exclude=.npm --exclude=build/browser-agent.tar.gz .",
     "watch": "jung -D '\\.npm|.git|node_modules|build|tools|tests' --run -- npm run build:all",
@@ -136,6 +137,8 @@
   },
   "dependencies": {
     "core-js": "^3.26.0",
+    "fflate": "^0.7.4",
+    "rrweb": "^2.0.0-alpha.8",
     "web-vitals": "^3.1.0"
   },
   "devDependencies": {
@@ -147,18 +150,19 @@
     "@babel/preset-env": "^7.20.2",
     "@babel/register": "^7.21.0",
     "@faker-js/faker": "^7.6.0",
-    "@fastify/cors": "^8.2.0",
-    "@fastify/multipart": "^7.3.0",
-    "@fastify/static": "^6.6.0",
+    "@fastify/compress": "^6.2.1",
+    "@fastify/cors": "^8.2.1",
+    "@fastify/multipart": "^7.6.0",
+    "@fastify/static": "^6.10.1",
     "@newrelic/newrelic-oss-cli": "^0.1.2",
     "@newrelic/nr-querypack": "https://git@github.com/newrelic/nr-querypack",
     "@octokit/rest": "^19.0.7",
-    "@wdio/cli": "^8.1.2",
-    "@wdio/local-runner": "^8.1.2",
-    "@wdio/mocha-framework": "^8.1.2",
-    "@wdio/sauce-service": "^8.1.2",
-    "@wdio/selenium-standalone-service": "^8.1.2",
-    "@wdio/spec-reporter": "^8.1.2",
+    "@wdio/cli": "^8.10.5",
+    "@wdio/local-runner": "^8.10.5",
+    "@wdio/mocha-framework": "^8.10.4",
+    "@wdio/sauce-service": "^8.10.5",
+    "@wdio/selenium-standalone-service": "^8.10.4",
+    "@wdio/spec-reporter": "^8.10.5",
     "aws-sdk": "^2.894.0",
     "babel-jest": "^29.4.1",
     "babel-loader": "^8.2.5",
@@ -168,7 +172,7 @@
     "chalk": "^5.1.2",
     "charm": "^1.0.1",
     "concat-stream": "^1.5.1",
-    "deepmerge-ts": "^4.2.2",
+    "deepmerge-ts": "^5.1.0",
     "defined": "^1.0.0",
     "dotenv-webpack": "^8.0.1",
     "eslint": "^8.34.0",
@@ -177,17 +181,18 @@
     "eslint-plugin-n": "^15.6.1",
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-sonarjs": "^0.19.0",
-    "fastify": "^4.13.0",
-    "fastify-plugin": "^4.4.0",
-    "filesize": "^10.0.6",
+    "fastify": "^4.17.0",
+    "fastify-plugin": "^4.5.0",
+    "filesize": "^10.0.7",
     "fs-extra": "^11.1.0",
     "function-bind": "^1.1.1",
-    "glob": "^7.0.5",
+    "glob": "^10.2.5",
     "gzip-size": "^7.0.0",
     "html-webpack-plugin": "^5.5.0",
     "husky": "^8.0.0",
     "jest": "^28.1.1",
     "jest-environment-jsdom": "28.1.1",
+    "jest-extended": "^3.2.4",
     "jquery": "1.11.3",
     "jung": "^2.1.0",
     "just-debounce": "^1.0.0",
@@ -197,13 +202,16 @@
     "npm-run-all": "^4.1.5",
     "object-inspect": "^1.5.0",
     "octokit": "^2.0.14",
+    "path-browserify": "^1.0.1",
     "preprocessify": "0.0.6",
+    "process": "^0.11.10",
     "request": "2.74.0",
     "sauce-connect-launcher": "^1.2.4",
-    "saucelabs": "^7.2.0",
+    "saucelabs": "^7.2.1",
     "semver": "^5.3.0",
     "serialize-anything": "^1.2.3",
-    "sinon": "^1.17.5",
+    "sinon": "^2.4.1",
+    "stream-browserify": "^3.0.0",
     "tap-parser": "^1.2.2",
     "tape": "^4.8.0",
     "through": "^2.3.8",
@@ -215,6 +223,7 @@
     "webpack": "^5.74.0",
     "webpack-bundle-analyzer": "^4.7.0",
     "webpack-cli": "^4.10.0",
+    "webpack-stream": "^7.0.0",
     "yargs": "^17.6.2"
   },
   "files": [

package/src/cdn/polyfills.js

@@ -5,8 +5,10 @@
 
 import 'core-js/stable/promise'
 import 'core-js/stable/array/includes'
-import 'core-js/stable/array/from'
 import 'core-js/stable/array/find'
+import 'core-js/stable/array/flat'
+import 'core-js/stable/array/flat-map'
+import 'core-js/stable/array/from'
 import 'core-js/stable/array/some'
 import 'core-js/stable/object/assign'
 import 'core-js/stable/object/entries'
@@ -15,3 +17,4 @@ import 'core-js/stable/map'
 import 'core-js/stable/reflect'
 import 'core-js/stable/set'
 import 'core-js/stable/weak-set'
+import 'core-js/stable/object/get-own-property-descriptors'

package/src/common/config/state/configurable.js

@@ -1,32 +1,26 @@
-import { getFrozenAttributes } from '../../../loaders/features/featureDependencies'
 import { warn } from '../../util/console'
 
-export class Configurable {
-  constructor (obj, model) {
-    Object.assign(this, setValues(obj, model))
-  }
-}
-
-function setValues (obj, model) {
-  const state = {}
+export function getModeledObject (obj, model) {
   try {
-    if (!obj || typeof obj !== 'object') return warn('New setting a Configurable requires an object as input')
+    if (!obj || typeof obj !== 'object') return warn('Setting a Configurable requires an object as input')
     if (!model || typeof model !== 'object') return warn('Setting a Configurable requires a model to set its initial properties')
-    Object.assign(state, model)
-    Object.entries(obj).forEach(([key, value]) => {
-      if (!Object.keys(model).includes(key)) return
-      const frozenAttrs = getFrozenAttributes(key)
-      if (frozenAttrs.length && value && typeof value === 'object') {
-        frozenAttrs.forEach(attr => {
-          if (attr in value) {
-            warn(`"${attr}" is a protected attribute and can not be changed in feature ${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) {
+          warn('An error occurred while setting a property of a Configurable', e)
+        }
       }
-      state[key] = value
-    })
-    return state
+    }
+    return output
   } catch (err) {
     warn('An error occured while setting a Configurable', err)
   }

package/src/common/config/state/info.js

@@ -1,5 +1,5 @@
 import { defaults as nrDefaults, gosNREUMInitializedAgents } from '../../window/nreum'
-import { Configurable } from './configurable'
+import { getModeledObject } from './configurable'
 
 const model = {
   // preset defaults
@@ -44,6 +44,6 @@ export function getInfo (id) {
 
 export function setInfo (id, obj) {
   if (!id) throw new Error('All info objects require an agent identifier!')
-  _cache[id] = new Configurable(obj, model)
+  _cache[id] = getModeledObject(obj, model)
   gosNREUMInitializedAgents(id, _cache[id], 'info')
 }

package/src/common/config/state/init.js

@@ -1,34 +1,68 @@
 
 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'
+import { getModeledObject } 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 }
+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: 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 += `,${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 = {}
@@ -41,7 +75,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')
 }
 

package/src/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,
@@ -20,6 +20,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/src/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'
@@ -23,7 +22,6 @@ const model = {
   releaseIds: {},
   session: undefined,
   xhrWrappable: typeof globalScope.XMLHttpRequest?.prototype?.addEventListener === 'function',
-  userAgent,
   version: VERSION
 }
 
@@ -37,6 +35,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/src/common/drain/drain.js

@@ -55,7 +55,7 @@ export function drain (agentIdentifier = '', featureName = 'feature') {
 
   // 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(([key, values]) => values.staged)) {
     items.sort((a, b) => a[1].priority - b[1].priority)
     items.forEach(([group]) => {

package/src/common/harvest/harvest-scheduler.js

@@ -68,22 +68,47 @@ export class HarvestScheduler extends SharedContext {
     if (this.aborted) return
     var scheduler = this
 
-    if (this.opts.getPayload) { // Ajax & PVT
-      var submitMethod = getSubmitMethod(this.endpoint, opts)
+    let harvests = []
+    let submitMethod
+
+    if (this.opts.getPayload) { // 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) 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/src/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'
@@ -18,6 +18,23 @@ import { SharedContext } from '../context/shared-context'
 import { VERSION } from '../constants/env'
 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 {
@@ -34,55 +51,48 @@ 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) {
+   * 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)
+    if (payload.body) mapOwn(payload.body, makeBody)
+    if (payload.qs) mapOwn(payload.qs, makeQueryString)
 
-    var payload = { body: makeBody(), qs: makeQueryString() }
-    var caller = this.obfuscator.shouldObfuscate() ? (...args) => this.obfuscateAndSend(...args) : (...args) => this._send(...args)
+    var newPayload = { body: makeBody(), qs: makeQueryString() }
+    var caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this)
 
-    return caller(endpoint, payload, opts, submitMethod, cbFinished)
+    return caller({ ...spec, payload: newPayload })
   }
 
-  obfuscateAndSend (endpoint, payload, opts, submitMethod, cbFinished) {
+  /**
+   * Apply obfuscation rules to the payload and then initial the harvest network call.
+   * @param {NetworkSendSpec} spec Specification for sending data
+   */
+  obfuscateAndSend (spec) {
+    const { payload = {} } = spec
     applyFnToProps(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e'])
-    return this._send(endpoint, payload, opts, submitMethod, cbFinished)
+    return this._send({ ...spec, payload })
   }
 
-  _send (endpoint, payload, opts, submitMethod, cbFinished) {
+  _send ({ endpoint, payload = {}, opts = {}, submitMethod, cbFinished, customUrl, gzip, includeBaseParams = true }) {
     var info = getInfo(this.sharedContext.agentIdentifier)
     if (!info.errorBeacon) return false
 
@@ -95,11 +105,10 @@ 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)
+    var url = customUrl || this.getScheme() + '://' + info.errorBeacon + '/' + endpoint + '/1/' + info.licenseKey + '?'
 
+    var baseParams = includeBaseParams ? this.baseQueryString() : ''
+    var params = payload.qs ? encodeObj(payload.qs, agentRuntime.maxBytes) : ''
     if (!submitMethod) {
       submitMethod = getSubmitMethod(endpoint, opts)
     }
@@ -107,29 +116,43 @@ export class Harvest extends SharedContext {
     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 = url + baseParams + params
+
+    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 = []
+
+    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 && 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 }
+        var result = { sent: true, status: this.status }
         if (this.status === 429) {
           result.retry = true
           result.delay = this.tooManyRequestsDelay
@@ -147,7 +170,7 @@ 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
@@ -162,14 +185,14 @@ export class Harvest extends SharedContext {
     var ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location
 
     return ([
-      '?a=' + info.applicationID,
+      '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'), // the 0 id encaps all untrackable and default traffic
+      '&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(''))
@@ -241,7 +264,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
     }