@newrelic/browser-agent 1.252.1 → 1.253.0

package/src/common/timing/nav-timing.js

@@ -25,7 +25,7 @@ var RESPONSE = 'response'
 var LOAD_EVENT = 'loadEvent'
 var DOM_CONTENT_LOAD_EVENT = 'domContentLoadedEvent'
 
-export var navTimingValues = []
+export const navTimingValues = []
 
 function getPntType (type) {
   if (typeof type === 'number') return type
@@ -72,6 +72,10 @@ export function addPN (pn, v) {
   return v
 }
 
+/**
+ * By side effect, this modifies 'obj' with a mapping of the 'prop' provided to a 'value', and invalid values are not added.
+ * On the other hand, the local navTimingValues array gets the value appended if valid and 'undefined' appended if invalid, regardless.
+ */
 function handleValue (value, obj, prop, isOldApi) {
   /*
   For L2 Timing API, the value will already be a relative-to-previous-document DOMHighResTimeStamp.
@@ -85,6 +89,6 @@ function handleValue (value, obj, prop, isOldApi) {
     }
     value = Math.round(value)
     obj[prop] = value
-  }
-  navTimingValues.push(value)
+    navTimingValues.push(value)
+  } else navTimingValues.push(undefined)
 }

package/src/common/timing/now.js

@@ -5,5 +5,5 @@
 
 // This is our own layer around performance.now. It's not strictly necessary, but we keep it in case of future mod-ing of the value for refactor purpose.
 export function now () {
-  return Math.round(performance.now())
+  return Math.floor(performance.now())
 }

package/src/common/util/feature-flags.js

@@ -11,7 +11,7 @@ const bucketMap = {
   stn: [FEATURE_NAMES.sessionTrace],
   err: [FEATURE_NAMES.jserrors, FEATURE_NAMES.metrics],
   ins: [FEATURE_NAMES.pageAction],
-  spa: [FEATURE_NAMES.spa],
+  spa: [FEATURE_NAMES.spa, FEATURE_NAMES.softNav],
   sr: [FEATURE_NAMES.sessionReplay, FEATURE_NAMES.sessionTrace]
 }
 

package/src/common/wrap/index.js

@@ -8,10 +8,9 @@ import { wrapHistory } from './wrap-history'
 import { wrapJsonP } from './wrap-jsonp'
 import { wrapMutation } from './wrap-mutation'
 import { wrapPromise } from './wrap-promise'
-import { wrapRaf } from './wrap-raf'
 import { wrapTimer } from './wrap-timer'
 import { wrapXhr } from './wrap-xhr'
 
 export {
-  wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr
+  wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapTimer, wrapXhr
 }

package/src/common/wrap/wrap-events.js

@@ -7,16 +7,16 @@
  * This module is used directly by: session_trace.
  * It is also called by -> wrapXhr <-, so see "wrap-xhr.js" for features that use this indirectly.
  */
-import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
+import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { createWrapperWithEmitter as wfn } from './wrap-function'
 import { getOrSet } from '../util/get-or-set'
 import { globalScope, isBrowserScope } from '../constants/runtime'
+import { ObservationContextManager } from '../context/observation-context-manager'
 
 const wrapped = {}
 const XHR = globalScope.XMLHttpRequest
 const ADD_EVENT_LISTENER = 'addEventListener'
 const REMOVE_EVENT_LISTENER = 'removeEventListener'
-const flag = `nr@wrapped:${contextId}`
 
 /**
  * Wraps `addEventListener` and `removeEventListener` on: global scope; the prototype of `XMLHttpRequest`, and
@@ -49,7 +49,7 @@ export function wrapEvents (sharedEE) {
       return
     }
 
-    var wrapped = getOrSet(originalListener, flag, function () {
+    var wrapped = getOrSet(originalListener, ObservationContextManager.contextWrappedId, function () {
       var listener = {
         object: wrapHandleEvent,
         function: originalListener

package/src/common/wrap/wrap-fetch.js

@@ -6,8 +6,9 @@
  * @file Wraps `fetch` and related methods for instrumentation.
  * This module is used by: ajax, spa.
  */
-import { ee as baseEE, contextId } from '../event-emitter/contextual-ee'
+import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
+import { ObservationContextManager } from '../context/observation-context-manager'
 
 var prefix = 'fetch-'
 var bodyPrefix = prefix + 'body-'
@@ -74,7 +75,7 @@ export function wrapFetch (sharedEE) {
         // we are wrapping args in an array so we can preserve the reference
         ee.emit(prefix + 'before-start', [args], ctx)
         var dtPayload
-        if (ctx[contextId] && ctx[contextId].dt) dtPayload = ctx[contextId].dt
+        if (ctx[ObservationContextManager.contextId] && ctx[ObservationContextManager.contextId].dt) dtPayload = ctx[ObservationContextManager.contextId].dt
 
         var origPromiseFromFetch = fn.apply(this, args)
 

package/src/common/wrap/wrap-function.js

@@ -7,9 +7,7 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-import { bundleId } from '../ids/bundle-id'
-
-export const flag = `nr@original:${bundleId}`
+import { ObservationContextManager } from '../context/observation-context-manager'
 
 /**
  * A convenience alias of `hasOwnProperty`.
@@ -42,7 +40,7 @@ export function createWrapperWithEmitter (emitter, always) {
    * As a property on a wrapped function, contains the original function.
    * @type {string}
    */
-  wrapFn.flag = flag
+  wrapFn.flag = ObservationContextManager.contextOriginalId
 
   return wrapFn
 
@@ -61,7 +59,7 @@ export function createWrapperWithEmitter (emitter, always) {
 
     if (!prefix) prefix = ''
 
-    nrWrapper[flag] = fn
+    nrWrapper[ObservationContextManager.contextOriginalId] = fn
     copy(fn, nrWrapper, emitter)
     return nrWrapper
 
@@ -215,5 +213,5 @@ function copy (from, to, emitter) {
  * @returns {boolean} Whether the passed function is ineligible to be wrapped.
  */
 function notWrappable (fn) {
-  return !(fn && typeof fn === 'function' && fn.apply && !fn[flag])
+  return !(fn && typeof fn === 'function' && fn.apply && !fn[ObservationContextManager.contextOriginalId])
 }

package/src/common/wrap/wrap-promise.js

@@ -7,9 +7,10 @@
  * This module is used by: spa.
  */
 
-import { createWrapperWithEmitter as wrapFn, flag } from './wrap-function'
+import { createWrapperWithEmitter as wrapFn } from './wrap-function'
 import { ee as baseEE } from '../event-emitter/contextual-ee'
 import { globalScope } from '../constants/runtime'
+import { ObservationContextManager } from '../context/observation-context-manager'
 
 const wrapped = {}
 
@@ -122,7 +123,7 @@ export function wrapPromise (sharedEE) {
 
       return origFnCallWithThis
     }
-    prevPromiseObj.prototype.then[flag] = prevPromiseOrigThen
+    prevPromiseObj.prototype.then[ObservationContextManager.contextOriginalId] = prevPromiseOrigThen
 
     promiseEE.on('executor-start', function (args) {
       args[0] = promiseWrapper(args[0], 'resolve-', this, null, false)

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

@@ -2,7 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { registerHandler as register } from '../../../common/event-emitter/register-handler'
+import { registerHandler } from '../../../common/event-emitter/register-handler'
 import { stringify } from '../../../common/util/stringify'
 import { nullable, numeric, getAddStringContext, addCustomAttributes } from '../../../common/serialize/bel-serializer'
 import { handle } from '../../../common/event-emitter/handle'
@@ -14,6 +14,7 @@ import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../metrics/constants'
 import { AggregateBase } from '../../utils/aggregate-base'
 import { parseGQL } from './gql'
+import { getNREUMInitializedAgent } from '../../../common/window/nreum'
 
 export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
@@ -22,7 +23,7 @@ export class Aggregate extends AggregateBase {
     const agentInit = getConfiguration(agentIdentifier)
     const allAjaxIsEnabled = agentInit.ajax.enabled !== false
 
-    register('xhr', storeXhr, this.featureName, this.ee)
+    registerHandler('xhr', storeXhr, this.featureName, this.ee)
     if (!allAjaxIsEnabled) {
       this.drain()
       return // feature will only collect timeslice metrics & ajax trace nodes if it's not fully enabled
@@ -44,20 +45,21 @@ export class Aggregate extends AggregateBase {
     this.prepareHarvest = prepareHarvest
     this.getStoredEvents = function () { return { ajaxEvents, spaAjaxEvents } }
 
-    ee.on('interactionSaved', (interaction) => {
-      if (!spaAjaxEvents[interaction.id]) return
-      // remove from the spaAjaxEvents buffer, and let spa harvest it
-      delete spaAjaxEvents[interaction.id]
-    })
-    ee.on('interactionDiscarded', (interaction) => {
+    // --- v Used by old spa feature
+    ee.on('interactionDone', (interaction, wasSaved) => {
       if (!spaAjaxEvents[interaction.id]) return
 
-      spaAjaxEvents[interaction.id].forEach(function (item) {
-        // move it from the spaAjaxEvents buffer to the ajaxEvents buffer for harvesting here
-        ajaxEvents.push(item)
-      })
+      if (!wasSaved) { // if the ixn was saved, then its ajax reqs are part of the payload whereas if it was discarded, it should still be harvested in the ajax feature itself
+        spaAjaxEvents[interaction.id].forEach(function (item) {
+          ajaxEvents.push(item)
+        })
+      }
       delete spaAjaxEvents[interaction.id]
     })
+    // --- ^
+    // --- v Used by new soft nav
+    registerHandler('returnAjax', event => ajaxEvents.push(event), this.featureName, this.ee)
+    // --- ^
 
     const scheduler = new HarvestScheduler('events', {
       onFinished: onEventsHarvestFinished,
@@ -82,17 +84,30 @@ export class Aggregate extends AggregateBase {
         hash = stringify([params.status, params.host, params.pathname])
       }
 
+      const shouldCollect = shouldCollectEvent(params)
+      const ajaxMetricDenyListEnabled = agentInit.feature_flags?.includes('ajax_metrics_deny_list')
+
       // store as metric
-      aggregator.store('xhr', hash, params, metrics)
+      if (shouldCollect || !ajaxMetricDenyListEnabled) {
+        aggregator.store('xhr', hash, params, metrics)
+      }
 
       if (!allAjaxIsEnabled) return
 
-      if (!shouldCollectEvent(params)) {
+      if (!shouldCollect) {
         if (params.hostname === beacon || (proxyBeacon && params.hostname === proxyBeacon)) {
           // This doesn't make a distinction if the same-domain request is going to a different port or path...
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee)
+
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/Agent'], undefined, FEATURE_NAMES.metrics, ee)
+          }
         } else {
           handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Events/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee)
+
+          if (ajaxMetricDenyListEnabled) {
+            handle(SUPPORTABILITY_METRIC_CHANNEL, ['Ajax/Metrics/Excluded/App'], undefined, FEATURE_NAMES.metrics, ee)
+          }
         }
         return
       }
@@ -125,12 +140,14 @@ export class Aggregate extends AggregateBase {
         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
+      const softNavInUse = Boolean(getNREUMInitializedAgent(agentIdentifier)?.features?.[FEATURE_NAMES.softNav])
+
+      if (softNavInUse) { // For newer soft nav (when running), pass the event to it for evaluation -- either part of an interaction or is given back
+        handle('ajax', [event], undefined, FEATURE_NAMES.softNav, ee)
+      } else if (this.spaNode) { // For old spa (when running), if the ajax happened inside an interaction, hold it until the interaction finishes
+        const interactionId = this.spaNode.interaction.id
         spaAjaxEvents[interactionId] = spaAjaxEvents[interactionId] || []
         spaAjaxEvents[interactionId].push(event)
       } else {
@@ -209,6 +226,7 @@ export class Aggregate extends AggregateBase {
 
       for (var i = 0; i < events.length; i++) {
         var event = events[i]
+
         var fields = [
           numeric(event.startTime),
           numeric(event.endTime - event.startTime),

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

@@ -20,6 +20,7 @@ import { globalScope } from '../../../common/constants/runtime'
 import { FEATURE_NAME } from '../constants'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { AggregateBase } from '../../utils/aggregate-base'
+import { getNREUMInitializedAgent } from '../../../common/window/nreum'
 
 /**
  * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
@@ -33,18 +34,17 @@ export class Aggregate extends AggregateBase {
     this.stackReported = {}
     this.observedAt = {}
     this.pageviewReported = {}
-    this.errorCache = {}
+    this.bufferedErrorsUnderSpa = {}
     this.currentBody = undefined
     this.errorOnPage = false
 
     // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionSaved', (interaction) => this.onInteractionSaved(interaction))
-
-    // this will need to change to match whatever ee we use in the instrument
-    this.ee.on('interactionDiscarded', (interaction) => this.onInteractionDiscarded(interaction))
+    this.ee.on('interactionDone', (interaction, wasSaved) => this.onInteractionDone(interaction, wasSaved))
 
     register('err', (...args) => this.storeError(...args), this.featureName, this.ee)
     register('ierr', (...args) => this.storeError(...args), this.featureName, this.ee)
+    register('softNavFlush', (interactionId, wasFinished, softNavAttrs) =>
+      this.onSoftNavNotification(interactionId, wasFinished, softNavAttrs), this.featureName, this.ee) // when an ixn is done or cancelled
 
     const harvestTimeSeconds = getConfigurationValue(this.agentIdentifier, 'jserrors.harvestTimeSeconds') || 10
 
@@ -197,98 +197,95 @@ export class Aggregate extends AggregateBase {
     var type = internal ? 'ierr' : 'err'
     var newMetrics = { time }
 
-    // sr, stn and spa aggregators listen to this event - stn sends the error in its payload,
-    // and spa annotates the error with interaction info
-    const msg = [type, bucketHash, params, newMetrics]
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionTrace, this.ee)
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.spa, this.ee)
-    handle('errorAgg', msg, undefined, FEATURE_NAMES.sessionReplay, this.ee)
-
+    // Trace sends the error in its payload, and both trace & replay simply listens for any error to occur.
+    const jsErrorEvent = [type, bucketHash, params, newMetrics, customAttributes]
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionTrace, this.ee)
+    handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.sessionReplay, this.ee)
     // still send EE events for other features such as above, but stop this one from aggregating internal data
     if (this.blocked) return
-    var att = getInfo(this.agentIdentifier).jsAttributes
-    if (params._interactionId != null) {
-      // hold on to the error until the interaction finishes
-      this.errorCache[params._interactionId] = this.errorCache[params._interactionId] || []
-      this.errorCache[params._interactionId].push([type, bucketHash, params, newMetrics, att, customAttributes])
-    } else {
-      // store custom attributes
-      var customParams = {}
-      mapOwn(att, setCustom)
-      if (customAttributes) {
-        mapOwn(customAttributes, setCustom)
-      }
-
-      var jsAttributesHash = stringHashCode(stringify(customParams))
-      var aggregateHash = bucketHash + ':' + jsAttributesHash
-      this.aggregator.store(type, aggregateHash, params, newMetrics, customParams)
-    }
 
-    function setCustom (key, val) {
-      customParams[key] = (val && typeof val === 'object' ? stringify(val) : val)
+    const softNavInUse = Boolean(getNREUMInitializedAgent(this.agentIdentifier)?.features[FEATURE_NAMES.softNav])
+    // Note: the following are subject to potential race cond wherein if the other feature aren't fully initialized, it'll be treated as there being no associated interaction.
+    // They each will also tack on their respective properties to the params object as part of the decision flow.
+    if (softNavInUse) handle('jserror', [params, time], undefined, FEATURE_NAMES.softNav, this.ee)
+    else handle('errorAgg', jsErrorEvent, undefined, FEATURE_NAMES.spa, this.ee)
+
+    if (params.browserInteractionId && !params._softNavFinished) { // hold onto the error until the in-progress interaction is done, eithered saved or discarded
+      this.bufferedErrorsUnderSpa[params.browserInteractionId] ??= []
+      this.bufferedErrorsUnderSpa[params.browserInteractionId].push(jsErrorEvent)
+    } else if (params._interactionId != null) { // same as above, except tailored for the way old spa does it
+      this.bufferedErrorsUnderSpa[params._interactionId] = this.bufferedErrorsUnderSpa[params._interactionId] || []
+      this.bufferedErrorsUnderSpa[params._interactionId].push(jsErrorEvent)
+    } else {
+      // Either there is no interaction (then all these params properties will be undefined) OR there's a related soft navigation that's already completed.
+      // The old spa does not look up completed interactions at all, so there's no need to consider it.
+      this.#storeJserrorForHarvest(jsErrorEvent, params.browserInteractionId !== undefined, params._softNavAttributes)
     }
   }
 
-  onInteractionSaved (interaction) {
-    if (!this.errorCache[interaction.id] || this.blocked) return
+  #storeJserrorForHarvest (errorInfoArr, softNavOccurredFinished, softNavCustomAttrs = {}) {
+    let [type, bucketHash, params, newMetrics, localAttrs] = errorInfoArr
+    const allCustomAttrs = {}
 
-    this.errorCache[interaction.id].forEach((item) => {
-      var customParams = {}
-      var globalCustomParams = item[4]
-      var localCustomParams = item[5]
+    if (softNavOccurredFinished) {
+      Object.entries(softNavCustomAttrs).forEach(([k, v]) => setCustom(k, v)) // when an ixn finishes, it'll include stuff in jsAttributes + attrs specific to the ixn
+      bucketHash += params.browserInteractionId
 
-      mapOwn(globalCustomParams, setCustom)
-      mapOwn(interaction.root.attrs.custom, setCustom)
-      mapOwn(localCustomParams, setCustom)
-
-      var params = item[2]
-      params.browserInteractionId = interaction.root.attrs.id
-      delete params._interactionId
-
-      if (params._interactionNodeId) {
-        params.parentNodeId = params._interactionNodeId.toString()
-        delete params._interactionNodeId
-      }
-
-      var hash = item[1] + interaction.root.attrs.id
-      var jsAttributesHash = stringHashCode(stringify(customParams))
-      var aggregateHash = hash + ':' + jsAttributesHash
+      delete params._softNavAttributes // cleanup temp properties from synchronous evaluation; this is harmless when async from soft nav (properties DNE)
+      delete params._softNavFinished
+    } else { // interaction was cancelled -> error should not be associated OR there was no interaction
+      Object.entries(getInfo(this.agentIdentifier).jsAttributes).forEach(([k, v]) => setCustom(k, v))
+      delete params.browserInteractionId
+    }
+    if (localAttrs) Object.entries(localAttrs).forEach(([k, v]) => setCustom(k, v)) // local custom attrs are applied in either case with the highest precedence
 
-      this.aggregator.store(item[0], aggregateHash, params, item[3], customParams)
+    const jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
+    const aggregateHash = bucketHash + ':' + jsAttributesHash
+    this.aggregator.store(type, aggregateHash, params, newMetrics, allCustomAttrs)
 
-      function setCustom (key, val) {
-        customParams[key] = (val && typeof val === 'object' ? stringify(val) : val)
-      }
-    })
-    delete this.errorCache[interaction.id]
+    function setCustom (key, val) {
+      allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)
+    }
   }
 
-  onInteractionDiscarded (interaction) {
-    if (!this.errorCache || !this.errorCache[interaction.id] || this.blocked) return
+  // TO-DO: Remove this function when old spa is taken out. #storeJserrorForHarvest handles the work with the softnav feature.
+  onInteractionDone (interaction, wasSaved) {
+    if (!this.bufferedErrorsUnderSpa[interaction.id] || this.blocked) return
 
-    this.errorCache[interaction.id].forEach((item) => {
-      var customParams = {}
-      var globalCustomParams = item[4]
-      var localCustomParams = item[5]
+    this.bufferedErrorsUnderSpa[interaction.id].forEach((item) => {
+      var allCustomAttrs = {}
+      const localCustomAttrs = item[4]
 
-      mapOwn(globalCustomParams, setCustom)
-      mapOwn(interaction.root.attrs.custom, setCustom)
-      mapOwn(localCustomParams, setCustom)
+      mapOwn(interaction.root.attrs.custom, setCustom) // tack on custom attrs from the interaction
+      mapOwn(localCustomAttrs, setCustom)
 
       var params = item[2]
+      if (wasSaved) {
+        params.browserInteractionId = interaction.root.attrs.id
+        if (params._interactionNodeId) params.parentNodeId = params._interactionNodeId.toString()
+      }
       delete params._interactionId
       delete params._interactionNodeId
 
-      var hash = item[1]
-      var jsAttributesHash = stringHashCode(stringify(customParams))
+      var hash = wasSaved ? item[1] + interaction.root.attrs.id : item[1]
+      var jsAttributesHash = stringHashCode(stringify(allCustomAttrs))
       var aggregateHash = hash + ':' + jsAttributesHash
 
-      this.aggregator.store(item[0], aggregateHash, item[2], item[3], customParams)
+      this.aggregator.store(item[0], aggregateHash, params, item[3], allCustomAttrs)
 
       function setCustom (key, val) {
-        customParams[key] = (val && typeof val === 'object' ? stringify(val) : val)
+        allCustomAttrs[key] = (val && typeof val === 'object' ? stringify(val) : val)
       }
     })
-    delete this.errorCache[interaction.id]
+    delete this.bufferedErrorsUnderSpa[interaction.id]
+  }
+
+  onSoftNavNotification (interactionId, wasFinished, softNavAttrs) {
+    if (this.blocked) return
+
+    this.bufferedErrorsUnderSpa[interactionId]?.forEach(jsErrorEvent =>
+      this.#storeJserrorForHarvest(jsErrorEvent, wasFinished, softNavAttrs) // this should not modify the re-used softNavAttrs contents
+    )
+    delete this.bufferedErrorsUnderSpa[interactionId] // wipe the list of jserrors so they aren't duplicated by another call to the same id
   }
 }

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

@@ -112,7 +112,7 @@ export class Aggregate extends AggregateBase {
           this.drain()
         } catch (err) {
           this.ee.abort()
-          warn('RUM call failed. Agent shutting down.')
+          warn('RUM call failed. Agent shutting down.', err)
         }
       }
     })

package/src/features/page_view_event/aggregate/initialized-features.js

@@ -22,6 +22,7 @@ export function getActivatedFeaturesFlags (agentId) {
           flagArr.push('ins'); break
         case FEATURE_NAMES.sessionTrace:
           flagArr.push('stn'); break
+        case FEATURE_NAMES.softNav:
         case FEATURE_NAMES.spa:
           flagArr.push('spa'); break
       }