@newrelic/browser-agent 1.244.0 → 1.246.0

package/dist/types/features/ajax/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mDAgOC;IAzMC,qGAAwB;IACxB;;;;4BAAoC;IACpC;;;mBAA2E;CAwM9E;8BArO6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/ajax/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,mDAyOC;IAlNC,qGAAwB;IACxB;;;;4BAAoC;IACpC;;;mBAA2E;CAiN9E;8BA/O6B,4BAA4B"}

package/dist/types/features/page_view_event/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAA2C;IAC3C,mDAoBC;IAjBC,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAiBhC,gBA8EC;CACF;8BA5G6B,4BAA4B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_event/aggregate/index.js"],"names":[],"mappings":"AAcA;IACE,2BAA2C;IAC3C,mDAoBC;IAjBC,wBAAwB;IACxB,8BAA8B;IAC9B,8BAA8B;IAiBhC,gBAgFC;CACF;8BA9G6B,4BAA4B"}

package/dist/types/features/page_view_timing/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_timing/aggregate/index.js"],"names":[],"mappings":"AAuBA;IACE,2BAAiC;IAMjC,mDAoCC;IAjCC,eAAiB;IACjB,mBAAqB;IACrB,4BAA+B;IAuB7B,4BAGQ;IAOZ;;;OAGG;IACH,6BAFW,MAAM,QAOhB;IAED;;OAEG;IACH,uCAUC;IAED,mDAqBC;IAED,qCAKC;IAED,gDAWC;IAGD;;;;kBAWC;IAGD,8BAuBC;;CACF;8BAnK6B,4BAA4B;iCANzB,2CAA2C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_view_timing/aggregate/index.js"],"names":[],"mappings":"AAuBA;IACE,2BAAiC;IAMjC,mDAoCC;IAjCC,eAAiB;IACjB,mBAAqB;IACrB,4BAA+B;IAuB7B,4BAGQ;IAOZ;;;OAGG;IACH,6BAFW,MAAM,QAOhB;IAED;;OAEG;IACH,uCAUC;IAED,mDAsBC;IAED,qCAKC;IAED,gDAWC;IAGD;;;;kBAWC;IAGD,8BAuBC;;CACF;8BApK6B,4BAA4B;iCANzB,2CAA2C"}

package/dist/types/features/session_trace/aggregate/index.d.ts

@@ -37,6 +37,7 @@ export class Aggregate extends AggregateBase {
         body?: undefined;
     } | {
         qs: {
+            fsh?: number | undefined;
             st: any;
             /** hr === "hasReplay" in NR1, standalone is always checked and processed before harvesting
              * so a race condition between ST and SR states should not be a concern if implemented here */

package/dist/types/features/session_trace/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiCA;IACE,2BAAiC;IAGjC,iEAyHC;IAvHC,kBAA+C;IAK/C,sBAAiD;IACjD,yBAAc;IACd,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,kCAAyB;IAGzB,0CAAsC;IAuGxC,sEAcC;IA6CD,oDAOC;IAGD,oCAwBC;IAGD,uEAkBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;YA2BM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAKjJ;IAED,mEA6BC;;CACF;8BAjf6B,4BAA4B;6BAH7B,2BAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiCA;IACE,2BAAiC;IAGjC,iEAyHC;IAvHC,kBAA+C;IAK/C,sBAAiD;IACjD,yBAAc;IACd,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAC5G;;4EAEwE;IACxE,kCAAyB;IAGzB,0CAAsC;IAuGxC,sEAcC;IA6CD,oDAOC;IAGD,oCAwBC;IAGD,uEAkBC;IAED,oDAKC;IAED,wBAwBC;IAED,uCAuBC;IAGD,gDASC;IAID,qCAkBC;IAGD,qEAUC;IAGD,mEAUC;IAGD,yBAeC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAsBlB;IAGD;;;;;;;YAkCM;0GAC8F;;YAE9F;0FAC8E;;YAE9E,4IAA4I;;;;;;MAMjJ;IAED,mEA6BC;;CACF;8BAzf6B,4BAA4B;6BAH7B,2BAA2B"}

package/dist/types/features/spa/aggregate/index.d.ts

@@ -17,6 +17,7 @@ export class Aggregate extends AggregateBase {
         harvestTimeSeconds: any;
         interactionsToHarvest: never[];
         interactionsSent: never[];
+        disableSpaFix: boolean;
     };
     serializer: Serializer;
 }

package/dist/types/features/spa/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/index.js"],"names":[],"mappings":"AA4BA;IACE,2BAAiC;IACjC,mDA8rBC;IA3rBC;;;;;;;;;;;;;;;;MAgBC;IAED,uBAAsC;CA0qBzC;8BA1sB6B,4BAA4B;2BAJ/B,cAAc"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/index.js"],"names":[],"mappings":"AA4BA;IACE,2BAAiC;IACjC,mDAgsBC;IA7rBC;;;;;;;;;;;;;;;;;MAkBC;IAED,uBAAsC;CA0qBzC;8BA5sB6B,4BAA4B;2BAJ/B,cAAc"}

package/dist/types/features/spa/aggregate/serializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/serializer.js"],"names":[],"mappings":"AAUA;IAII;;;;;;OAMG;IACH,gBAFU,MAAM,GAAC,SAAS,CAEK;IAGjC,0EASC;IAED,oFAMC;IAED,iHAyJC;CACF;8BA9L6B,wCAAwC"}
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../../../../src/features/spa/aggregate/serializer.js"],"names":[],"mappings":"AAUA;IAII;;;;;;OAMG;IACH,gBAFU,MAAM,GAAC,SAAS,CAEK;IAGjC,0EASC;IAED,oFAMC;IAED,iHA+JC;CACF;8BApM6B,wCAAwC"}

package/dist/types/index.d.ts

@@ -1,6 +1,5 @@
 export { Agent } from "./loaders/agent";
 export { BrowserAgent } from "./loaders/browser-agent";
-export { WorkerAgent } from "./loaders/worker-agent";
 export { MicroAgent } from "./loaders/micro-agent";
 export { Ajax } from "./features/ajax";
 export { JSErrors } from "./features/jserrors";

package/dist/types/loaders/configure/public-path.npm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-path.npm.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/public-path.npm.js"],"names":[],"mappings":"AACO,2CAEN"}
+{"version":3,"file":"public-path.npm.d.ts","sourceRoot":"","sources":["../../../../src/loaders/configure/public-path.npm.js"],"names":[],"mappings":"AAAO,2CAEN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.244.0",
+  "version": "1.246.0",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "New Relic Browser Agent",
@@ -26,9 +26,6 @@
       "loaders/micro-agent": [
         "dist/types/loaders/micro-agent.d.ts"
       ],
-      "loaders/worker-agent": [
-        "dist/types/loaders/worker-agent.d.ts"
-      ],
       "features/ajax": [
         "dist/types/features/ajax/index.d.ts"
       ],
@@ -81,11 +78,6 @@
       "require": "./dist/cjs/loaders/micro-agent.js",
       "default": "./dist/esm/loaders/micro-agent.js"
     },
-    "./loaders/worker-agent": {
-      "types": "./dist/types/loaders/worker-agent.d.ts",
-      "require": "./dist/cjs/loaders/worker-agent.js",
-      "default": "./dist/esm/loaders/worker-agent.js"
-    },
     "./features/ajax": {
       "types": "./dist/types/features/ajax/index.d.ts",
       "require": "./dist/cjs/features/ajax/index.js",

package/src/cdn/polyfills.js

@@ -13,8 +13,12 @@ import 'core-js/stable/array/some'
 import 'core-js/stable/object/assign'
 import 'core-js/stable/object/entries'
 import 'core-js/stable/object/values'
+import 'core-js/stable/object/from-entries'
 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'
+import 'core-js/stable/url'
+import 'core-js/stable/url-search-params'
+import 'core-js/stable/string/starts-with'

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

@@ -13,7 +13,8 @@ export function getModeledObject (obj, model) {
     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])
+          if (Array.isArray(obj[key]) && Array.isArray(model[key])) output[key] = Array.from(new Set([...obj[key], ...model[key]]))
+          else 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)

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

@@ -29,6 +29,7 @@ const model = () => {
     }
   }
   return {
+    feature_flags: [],
     proxy: {
       assets: undefined, // if this value is set, it will be used to overwrite the webpack asset path used to fetch assets
       beacon: undefined // likewise for the url to which we send analytics

package/src/common/session/session-entity.js

@@ -25,9 +25,10 @@ const model = {
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplay: MODE.OFF,
+  sessionReplayMode: MODE.OFF,
   sessionReplaySentFirstChunk: false,
   sessionTraceMode: MODE.OFF,
+  traceHarvestStarted: false,
   custom: {}
 }
 export const SESSION_EVENTS = {
@@ -140,7 +141,7 @@ export class SessionEntity {
 
     // 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.
-    if (this.isNew === undefined) this.isNew = !Object.keys(initialRead).length
+    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 a modeled object here to help us know and manage what values are being used. -- see "model" above
     if (this.isNew) this.write(getModeledObject(this.state, model), true)

package/src/common/url/parse-url.js

@@ -3,15 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { globalScope, isBrowserScope } from '../constants/runtime'
-
-var stringsToParsedUrls = {}
+import { globalScope } from '../constants/runtime'
 
 export function parseUrl (url) {
-  if (url in stringsToParsedUrls) {
-    return stringsToParsedUrls[url]
-  }
-
   // Return if URL is a data URL, parseUrl assumes urls are http/https
   if ((url || '').indexOf('data:') === 0) {
     return {
@@ -19,52 +13,30 @@ export function parseUrl (url) {
     }
   }
 
-  let urlEl
-  var location = globalScope?.location
-  var ret = {}
-
-  if (isBrowserScope) {
-    // Use an anchor dom element to resolve the url natively.
-    urlEl = document.createElement('a')
-    urlEl.href = url
-  } else {
-    try {
-      urlEl = new URL(url, location.href)
-    } catch (err) {
-      return ret
+  try {
+    const parsedUrl = new URL(url, location.href)
+    const returnVal = {
+      port: parsedUrl.port,
+      hostname: parsedUrl.hostname,
+      pathname: parsedUrl.pathname,
+      search: parsedUrl.search,
+      protocol: parsedUrl.protocol.slice(0, parsedUrl.protocol.indexOf(':')),
+      sameOrigin: parsedUrl.protocol === globalScope?.location?.protocol && parsedUrl.host === globalScope?.location?.host
     }
-  }
-
-  ret.port = urlEl.port
-
-  var firstSplit = urlEl.href.split('://')
-
-  if (!ret.port && firstSplit[1]) {
-    ret.port = firstSplit[1].split('/')[0].split('@').pop().split(':')[1]
-  }
-  if (!ret.port || ret.port === '0') ret.port = (firstSplit[0] === 'https' ? '443' : '80')
-
-  // Host not provided in IE for relative urls
-  ret.hostname = (urlEl.hostname || location.hostname)
-
-  ret.pathname = urlEl.pathname
-
-  ret.protocol = firstSplit[0]
 
-  // Pathname sometimes doesn't have leading slash (IE 8 and 9)
-  if (ret.pathname.charAt(0) !== '/') ret.pathname = '/' + ret.pathname
-
-  // urlEl.protocol is ':' in old ie when protocol is not specified
-  var sameProtocol = !urlEl.protocol || urlEl.protocol === ':' || urlEl.protocol === location.protocol
-  var sameDomain = urlEl.hostname === location.hostname && urlEl.port === location.port
+    if (!returnVal.port || returnVal.port === '') {
+      if (parsedUrl.protocol === 'http:') returnVal.port = '80'
+      if (parsedUrl.protocol === 'https:') returnVal.port = '443'
+    }
 
-  // urlEl.hostname is not provided by IE for relative urls, but relative urls are also same-origin
-  ret.sameOrigin = sameProtocol && (!urlEl.hostname || sameDomain)
+    if (!returnVal.pathname || returnVal.pathname === '') {
+      returnVal.pathname = '/'
+    } else if (!returnVal.pathname.startsWith('/')) {
+      returnVal.pathname = `/${returnVal.pathname}`
+    }
 
-  // Only cache if url doesn't have a path
-  if (ret.pathname === '/') {
-    stringsToParsedUrls[url] = ret
+    return returnVal
+  } catch (err) {
+    return {}
   }
-
-  return ret
 }

package/src/common/util/type-check.js

@@ -0,0 +1,8 @@
+/**
+ * Tests a passed object to see if it is a pure object or not. All non-primatives in JS
+ * are technically objects and would pass a `typeof` check.
+ * @param {*} obj Input object to be tested
+**/
+export function isPureObject (obj) {
+  return obj?.constructor === ({}).constructor
+}

package/src/common/vitals/first-input-delay.js

@@ -13,8 +13,7 @@ if (isBrowserScope) {
     firstInputDelay.update({
       value: entries[0].startTime,
       entries,
-      attrs: { type: entries[0].name, fid: Math.round(value) },
-      shouldAddConnectionAttributes: true
+      attrs: { type: entries[0].name, fid: Math.round(value) }
     })
   })
 }

package/src/common/vitals/largest-contentful-paint.js

@@ -22,8 +22,7 @@ if (isBrowserScope) {
           ...(!!lcpEntry.url && { elUrl: cleanURL(lcpEntry.url) }),
           ...(!!lcpEntry.element?.tagName && { elTag: lcpEntry.element.tagName })
         }
-      }),
-      shouldAddConnectionAttributes: true
+      })
     })
   })
 }

package/src/common/vitals/vital-metric.js

@@ -8,7 +8,7 @@ export class VitalMetric {
     this.roundingMethod = typeof roundingMethod === 'function' ? roundingMethod : Math.floor
   }
 
-  update ({ value, entries = [], attrs = {}, shouldAddConnectionAttributes = false }) {
+  update ({ value, entries = [], attrs = {} }) {
     if (value < 0) return
     const state = {
       value: this.roundingMethod(value),
@@ -16,7 +16,7 @@ export class VitalMetric {
       entries,
       attrs
     }
-    if (shouldAddConnectionAttributes) addConnectionAttributes(state.attrs)
+
     this.history.push(state)
     this.#subscribers.forEach(cb => {
       try {
@@ -48,13 +48,3 @@ export class VitalMetric {
     return () => { this.#subscribers.delete(callback) }
   }
 }
-
-function addConnectionAttributes (obj) {
-  var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection // to date, both window & worker shares the same support for connection
-  if (!connection) return
-
-  if (connection.type) obj['net-type'] = connection.type
-  if (connection.effectiveType) obj['net-etype'] = connection.effectiveType
-  if (connection.rtt) obj['net-rtt'] = connection.rtt
-  if (connection.downlink) obj['net-dlink'] = connection.downlink
-}

package/src/features/ajax/aggregate/gql.js

@@ -0,0 +1,95 @@
+import { isPureObject } from '../../../common/util/type-check'
+
+/**
+ * @typedef {object} GQLMetadata
+ * @property {string} operationName Name of the operation
+ * @property {string} operationType Type of the operation
+ * @property {string} operationFramework Framework responsible for the operation
+ */
+
+/**
+ * Parses and returns the graphql metadata from a network request. If the network
+ * request is not a graphql call, undefined will be returned.
+ * @param {object|string} body Ajax request body
+ * @param {string} query Ajax request query param string
+ * @returns {GQLMetadata | undefined}
+ */
+export function parseGQL ({ body, query } = {}) {
+  if (!body && !query) return
+  try {
+    const gqlBody = parseBatchGQL(parseGQLContents(body))
+    if (gqlBody) return gqlBody
+    const gqlQuery = parseSingleGQL(parseGQLQueryString(query))
+    if (gqlQuery) return gqlQuery
+  } catch (err) {
+    // parsing failed, return undefined
+  }
+}
+
+/**
+ * @param {string|Object} gql The GraphQL object body sent to a GQL server
+ * @returns {GQLMetadata}
+ */
+function parseSingleGQL (contents) {
+  if (typeof contents !== 'object' || !contents.query || typeof contents.query !== 'string') return
+
+  /** parses gql query string and returns [fullmatch, type match, name match] */
+  const matches = contents.query.trim().match(/^(query|mutation|subscription)\s?(\w*)/)
+  const operationType = matches?.[1]
+  if (!operationType) return
+  const operationName = contents.operationName || matches?.[2] || 'Anonymous'
+  return {
+    operationName, // the operation name of the indiv query
+    operationType, // query, mutation, or subscription,
+    operationFramework: 'GraphQL'
+  }
+}
+
+function parseBatchGQL (contents) {
+  if (!contents) return
+  if (!Array.isArray(contents)) contents = [contents]
+
+  const opNames = []
+  const opTypes = []
+  for (let content of contents) {
+    const operation = parseSingleGQL(content)
+    if (!operation) continue
+
+    opNames.push(operation.operationName)
+    opTypes.push(operation.operationType)
+  }
+
+  if (!opTypes.length) return
+  return {
+    operationName: opNames.join(','), // the operation name of the indiv query -- joined by ',' for batched results
+    operationType: opTypes.join(','), // query, mutation, or subscription -- joined by ',' for batched results
+    operationFramework: 'GraphQL'
+  }
+}
+
+function parseGQLContents (gqlContents) {
+  let contents
+
+  if (!gqlContents || (typeof gqlContents !== 'string' && typeof gqlContents !== 'object')) return
+  else if (typeof gqlContents === 'string') contents = JSON.parse(gqlContents)
+  else contents = gqlContents
+
+  if (!isPureObject(contents) && !Array.isArray(contents)) return
+
+  let isValid = false
+  if (Array.isArray(contents)) isValid = contents.some(x => validateGQLObject(x))
+  else isValid = validateGQLObject(contents)
+
+  if (!isValid) return
+  return contents
+}
+
+function parseGQLQueryString (gqlQueryString) {
+  if (!gqlQueryString || typeof gqlQueryString !== 'string') return
+  const params = new URLSearchParams(gqlQueryString)
+  return parseGQLContents(Object.fromEntries(params))
+}
+
+function validateGQLObject (obj) {
+  return !(typeof obj !== 'object' || !obj.query || typeof obj.query !== 'string')
+}

package/src/features/ajax/aggregate/index.js

@@ -13,6 +13,7 @@ import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
+import { parseGQL } from './gql'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -119,6 +120,14 @@ export class Aggregate extends AggregateBase {
         event.spanTimestamp = xhrContext.dt.timestamp
       }
 
+      // parsed from the AJAX body, looking for operationName param & parsing query for operationType
+      event.gql = params.gql = parseGQL({
+        body: this.body,
+        query: this?.parsedOrigin?.search
+      })
+
+      if (event.gql) handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/GraphQL/Bytes-Added', stringify(event.gql).length], undefined, FEATURE_NAMES.metrics, ee)
+
       // if the ajax happened inside an interaction, hold it until the interaction finishes
       if (this.spaNode) {
         var interactionId = this.spaNode.interaction.id
@@ -221,7 +230,8 @@ export class Aggregate extends AggregateBase {
         var insert = '2,'
 
         // add custom attributes
-        var attrParts = addCustomAttributes(getInfo(agentIdentifier).jsAttributes || {}, this.addString)
+        // gql decorators are added as custom attributes to alleviate need for new BEL schema
+        var attrParts = addCustomAttributes({ ...(getInfo(agentIdentifier).jsAttributes || {}), ...(event.gql || {}) }, this.addString)
         fields.unshift(numeric(attrParts.length))
 
         insert += fields.join(',')

package/src/features/ajax/instrument/index.js

@@ -157,6 +157,8 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
 
     this.startTime = now()
 
+    this.body = data
+
     this.listener = function (evt) {
       try {
         if (evt.type === 'abort' && !(context.loadCaptureCalled)) {
@@ -329,6 +331,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
     var method = ('' + ((target && target instanceof origRequest && target.method) ||
       opts.method || 'GET')).toUpperCase()
     this.params.method = method
+    this.body = opts.body
 
     this.txSize = dataSize(opts.body) || 0
   }

package/src/features/jserrors/aggregate/index.js

@@ -191,7 +191,7 @@ export class Aggregate extends AggregateBase {
       this.pageviewReported[bucketHash] = true
     }
 
-    if (agentRuntime?.session?.state?.sessionReplay) params.hasReplay = true
+    if (agentRuntime?.session?.state?.sessionReplayMode) params.hasReplay = true
     params.firstOccurrenceTimestamp = this.observedAt[bucketHash]
 
     var type = internal ? 'ierr' : 'err'

package/src/features/page_view_event/aggregate/index.js

@@ -69,6 +69,8 @@ export class Aggregate extends AggregateBase {
       at: info.atts
     }
 
+    if (agentRuntime.session) queryParameters.fsh = Number(agentRuntime.session.isNew) // "first session harvest" aka RUM request or PageView event of a session
+
     let body
     if (typeof info.jsAttributes === 'object' && Object.keys(info.jsAttributes).length > 0) {
       body = { ja: info.jsAttributes }

package/src/features/page_view_timing/aggregate/index.js

@@ -94,6 +94,7 @@ export class Aggregate extends AggregateBase {
 
   addTiming (name, value, attrs) {
     attrs = attrs || {}
+    addConnectionAttributes(attrs) // network conditions may differ from the actual for VitalMetrics when they were captured
 
     // If cls was set to another value by `onCLS`, then it's supported and is attached onto any timing but is omitted until such time.
     /*
@@ -175,3 +176,13 @@ export class Aggregate extends AggregateBase {
     return payload
   }
 }
+
+function addConnectionAttributes (obj) {
+  var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection // to date, both window & worker shares the same support for connection
+  if (!connection) return
+
+  if (connection.type) obj['net-type'] = connection.type
+  if (connection.effectiveType) obj['net-etype'] = connection.effectiveType
+  if (connection.rtt) obj['net-rtt'] = connection.rtt
+  if (connection.downlink) obj['net-dlink'] = connection.downlink
+}

package/src/features/session_replay/aggregate/index.js

@@ -133,14 +133,14 @@ export class Aggregate extends AggregateBase {
       this.ee.on(SESSION_EVENTS.RESUME, () => {
         // if the mode changed on a different tab, it needs to update this instance to match
         const { session } = getRuntime(this.agentIdentifier)
-        this.mode = session.state.sessionReplay
+        this.mode = session.state.sessionReplayMode
         if (!this.initialized || this.mode === MODE.OFF) return
         this.startRecording()
       })
 
       this.ee.on(SESSION_EVENTS.UPDATE, (type, data) => {
         if (!this.initialized || this.blocked || type !== SESSION_EVENT_TYPES.CROSS_TAB) return
-        if (this.mode !== MODE.OFF && data.sessionReplay === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB)
+        if (this.mode !== MODE.OFF && data.sessionReplayMode === MODE.OFF) this.abort(ABORT_REASONS.CROSS_TAB)
         this.mode = data.sessionReplay
       })
 
@@ -167,7 +167,7 @@ export class Aggregate extends AggregateBase {
 
             this.scheduler.startTimer(this.harvestTimeSeconds)
 
-            this.syncWithSessionManager({ sessionReplay: this.mode })
+            this.syncWithSessionManager({ sessionReplayMode: this.mode })
           }
         }
       }, this.featureName, this.ee)
@@ -201,7 +201,7 @@ export class Aggregate extends AggregateBase {
     // session replay samples can only be decided on the first load of a session
     // session replays can continue if already in progress
     if (!session.isNew) { // inherit the mode of the existing session
-      this.mode = session.state.sessionReplay
+      this.mode = session.state.sessionReplayMode
     } else {
       // The session is new... determine the mode the new session should start in
       if (fullSample) this.mode = MODE.FULL // full mode has precedence over error mode
@@ -241,7 +241,7 @@ export class Aggregate extends AggregateBase {
     }
     this.startRecording()
 
-    this.syncWithSessionManager({ sessionReplay: this.mode })
+    this.syncWithSessionManager({ sessionReplayMode: this.mode })
   }
 
   prepareHarvest () {
@@ -439,7 +439,7 @@ export class Aggregate extends AggregateBase {
     this.blocked = true
     this.mode = MODE.OFF
     this.stopRecording()
-    this.syncWithSessionManager({ sessionReplay: this.mode })
+    this.syncWithSessionManager({ sessionReplayMode: this.mode })
     this.clearTimestamps()
     this.ee.emit('REPLAY_ABORTED')
   }

package/src/features/session_trace/aggregate/index.js

@@ -125,7 +125,7 @@ export class Aggregate extends AggregateBase {
           this.ee.on(SESSION_EVENTS.PAUSE, () => { mostRecentModeKnown = sessionEntity.state.sessionTraceMode })
 
           if (!sessionEntity.isNew) { // inherit the same mode as existing session's Trace
-            if (sessionEntity.state.sessionReplay === MODE.OFF) this.isStandalone = true
+            if (sessionEntity.state.sessionReplayMode === MODE.OFF) this.isStandalone = true
             controlTraceOp(mostRecentModeKnown = sessionEntity.state.sessionTraceMode)
           } else { // for new sessions, see the truth table associated with NEWRELIC-8662 wrt the new Trace behavior under session management
             const replayMode = await getSessionReplayMode(agentIdentifier)
@@ -462,6 +462,13 @@ export class Aggregate extends AggregateBase {
     this.trace = {}
     this.nodeCount = 0
 
+    let firstHarvestOfSession
+    if (this.agentRuntime.session) {
+      const isFirstPayload = !this.agentRuntime.session.state.traceHarvestStarted
+      firstHarvestOfSession = { fsh: Number(isFirstPayload) } // converted to '0' | '1'
+      if (isFirstPayload) this.agentRuntime.session.write({ traceHarvestStarted: true })
+    }
+
     return {
       qs: {
         st: this.agentRuntime.offset,
@@ -472,7 +479,8 @@ export class Aggregate extends AggregateBase {
          * so that blob parsing doesn't need to happen to support UI/API functions  */
         fts: this.agentRuntime.offset + earliestTimeStamp,
         /** n === "nodeCount" in NR1, a count of nodes in the ST payload, so that blob parsing doesn't need to happen to support UI/API functions */
-        n: stns.length // node count
+        n: stns.length, // node count
+        ...firstHarvestOfSession
       },
       body: { res: stns }
     }

package/src/features/spa/aggregate/index.js

@@ -46,7 +46,9 @@ export class Aggregate extends AggregateBase {
       depth: 0,
       harvestTimeSeconds: getConfigurationValue(agentIdentifier, 'spa.harvestTimeSeconds') || 10,
       interactionsToHarvest: [],
-      interactionsSent: []
+      interactionsSent: [],
+      // The below feature flag is used to disable the SPA ajax fix for specific customers, see https://new-relic.atlassian.net/browse/NR-172169
+      disableSpaFix: (getConfigurationValue(agentIdentifier, 'feature_flags') || []).indexOf('disable-spa-fix') > -1
     }
 
     this.serializer = new Serializer(this)
@@ -279,7 +281,7 @@ export class Aggregate extends AggregateBase {
     // context is stored on the xhr and is shared with all callbacks associated
     // with the new xhr
     register('new-xhr', function () {
-      if (!state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
+      if (!state.disableSpaFix && !state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
         /*
          * The previous interaction was discarded before a route change. Restore the interaction
          * in case this XHR is associated with a route change.
@@ -382,7 +384,7 @@ export class Aggregate extends AggregateBase {
 
     register(FETCH_START, function (fetchArguments, dtPayload) {
       if (fetchArguments) {
-        if (!state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
+        if (!state.disableSpaFix && !state.currentNode && state.prevInteraction && !state.prevInteraction.ignored) {
           /*
            * The previous interaction was discarded before a route change. Restore the interaction
            * in case this XHR is associated with a route change.

package/src/features/spa/aggregate/serializer.js

@@ -102,7 +102,6 @@ export class Serializer extends SharedContext {
             nullable(attrs.firstPaint, numeric, true) +
             nullable(attrs.firstContentfulPaint, numeric, false)
           )
-
           var attrParts = addCustomAttributes(attrs.custom, addString)
           children = children.concat(attrParts)
           attrCount = attrParts.length
@@ -128,6 +127,13 @@ export class Serializer extends SharedContext {
             nullable(node.dt && node.dt.traceId, addString, true) +
             nullable(node.dt && node.dt.timestamp, numeric, false)
           )
+
+          // add params.gql here
+          if (Object.keys(params?.gql || {}).length) {
+            var ajaxAttrParts = addCustomAttributes(params.gql, addString)
+            children = children.concat(ajaxAttrParts)
+            attrCount = ajaxAttrParts.length
+          }
           break
 
         case 4:

package/src/features/utils/instrument-base.js

@@ -129,7 +129,7 @@ export class InstrumentBase extends FeatureBase {
     if (featureName === FEATURE_NAMES.sessionReplay) {
       if (!originals.MO) return false // Session Replay cannot work without Mutation Observer
       if (getConfigurationValue(this.agentIdentifier, 'session_trace.enabled') === false) return false // Session Replay as of now is tightly coupled with Session Trace in the UI
-      return !!session?.isNew || !!session?.state.sessionReplay // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
+      return !!session?.isNew || !!session?.state.sessionReplayMode // Session Replay should only try to run if already running from a previous page, or at the beginning of a session
     }
     return true
   }