@newrelic/browser-agent 0.1.229 → 0.1.231

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

@@ -0,0 +1,738 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*eslint no-undef: "error"*/
+import { registerHandler as register } from '../../../common/event-emitter/register-handler'
+import { parseUrl } from '../../../common/url/parse-url'
+import { shouldCollectEvent } from '../../../common/deny-list/deny-list'
+import { mapOwn } from '../../../common/util/map-own'
+import { navTimingValues as navTiming } from '../../../common/timing/nav-timing'
+import { generateUuid } from '../../../common/ids/unique-id'
+import { paintMetrics } from '../../../common/metrics/paint-metrics'
+import { Interaction } from './interaction'
+import { getConfigurationValue, getRuntime } from '../../../common/config/config'
+import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
+import { AggregateBase } from '../../utils/aggregate-base'
+import { HarvestScheduler } from '../../../common/harvest/harvest-scheduler'
+import { Serializer } from './serializer'
+import { ee } from '../../../common/event-emitter/contextual-ee'
+import * as CONSTANTS from '../constants'
+import { drain } from '../../../common/drain/drain'
+import { FEATURE_NAMES } from '../../../loaders/features/features'
+
+const {
+  FEATURE_NAME, INTERACTION_EVENTS, MAX_TIMER_BUDGET, FN_START, FN_END, CB_START, INTERACTION_API, REMAINING,
+  INTERACTION, SPA_NODE, JSONP_NODE, FETCH_START, FETCH_DONE, FETCH_BODY, JSONP_END, originalSetTimeout
+} = CONSTANTS
+export class Aggregate extends AggregateBase {
+  static featureName = FEATURE_NAME
+  constructor (agentIdentifier, aggregator) {
+    super(agentIdentifier, aggregator, FEATURE_NAME)
+
+    this.state = {
+      initialPageURL: getRuntime(agentIdentifier).origin,
+      lastSeenUrl: getRuntime(agentIdentifier).origin,
+      lastSeenRouteName: null,
+      timerMap: {},
+      timerBudget: MAX_TIMER_BUDGET,
+      currentNode: null,
+      prevNode: null,
+      nodeOnLastHashUpdate: null,
+      initialPageLoad: null,
+      pageLoaded: false,
+      childTime: 0,
+      depth: 0,
+      harvestTimeSeconds: getConfigurationValue(agentIdentifier, 'spa.harvestTimeSeconds') || 10,
+      interactionsToHarvest: [],
+      interactionsSent: []
+    }
+
+    this.serializer = new Serializer(this)
+
+    const { state, serializer } = this
+    let { blocked } = this
+
+    const baseEE = ee.get(agentIdentifier) // <-- parent baseEE
+    const mutationEE = baseEE.get('mutation')
+    const promiseEE = baseEE.get('promise')
+    const historyEE = baseEE.get('history')
+    const eventsEE = baseEE.get('events') // ajax --> ee(123).emit() ee()
+    const timerEE = baseEE.get('timer')
+    const fetchEE = baseEE.get('fetch')
+    const jsonpEE = baseEE.get('jsonp')
+    const xhrEE = baseEE.get('xhr')
+    const tracerEE = baseEE.get('tracer')
+
+    const scheduler = new HarvestScheduler('events', {
+      onFinished: onHarvestFinished,
+      retryDelay: state.harvestTimeSeconds
+    }, { agentIdentifier })
+    scheduler.harvest.on('events', onHarvestStarted)
+
+    // childTime is used when calculating exclusive time for a cb duration.
+    //
+    // Exclusive time will be different than the total time for either callbacks
+    // which synchronously invoke a customTracer callback or, trigger a synchronous
+    // event (eg. onreadystate=1 or popstate).
+    //
+    // At fn-end, childTime will contain the total time of all timed callbacks and
+    // event handlers which executed as a child of the current callback. At the
+    // begining of every callback, childTime is saved to the event context (which at
+    // that time contains the sum of its preceeding siblings) and is reset to 0. The
+    // callback is then executed, and its children may increase childTime.  At the
+    // end of the callback, it reports its exclusive time as its
+    // execution time - exlcuded. childTime is then reset to its previous
+    // value, and the totalTime of the callback that just finished executing is
+    // added to the childTime time.
+    //                                    | clock | childTime | ctx.ct | totalTime | exclusive |
+    // click fn-start                     |   0   |    0     |    0   |           |           |
+    //  | click begining:                 |   5   |    0     |    0   |           |           |
+    //  |   | custom-1 fn-start           |   10  |    0     |    0   |           |           |
+    //  |   |   |  custom-1 begining      |   15  |    0     |    0   |           |           |
+    //  |   |   |    |  custom-2 fn-start |   20  |    0     |    0   |           |           |
+    //  |   |   |    |  | custom-2        |   25  |    0     |    0   |           |           |
+    //  |   |   |    |  custom-2 fn-end   |   30  |    10    |    0   |     10    |     10    |
+    //  |   |   |  custom-1 middle        |   35  |    10    |    0   |           |           |
+    //  |   |   |    |  custom-3 fn-start |   40  |    0     |    10  |           |           |
+    //  |   |   |    |  | custom-3        |   45  |    0     |    10  |           |           |
+    //  |   |   |    |  custom-3 fn-end   |   50  |    20    |    0   |     10    |     10    |
+    //  |   |   |  custom-1 ending        |   55  |    20    |    0   |           |           |
+    //  |     custom-1 fn-end             |   60  |    50    |    0   |     50    |     30    |
+    //  | click ending:                   |   65  |    50    |        |           |           |
+    // click fn-end                       |   70  |    0     |    0   |     70    |     20    |
+
+    // if rum response determines that customer lacks entitlements for spa endpoint, block it
+    register('block-spa', () => {
+      blocked = true
+      scheduler.stopTimer(true)
+    }, this.featureName, baseEE)
+
+    if (!isEnabled()) return
+
+    state.initialPageLoad = new Interaction('initialPageLoad', 0, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier)
+    state.initialPageLoad.save = true
+    state.prevInteraction = state.initialPageLoad
+    state.currentNode = state.initialPageLoad.root // hint
+    // ensure that checkFinish calls are safe during initialPageLoad
+    state.initialPageLoad[REMAINING]++
+
+    register(FN_START, callbackStart, this.featureName, baseEE)
+    register(CB_START, callbackStart, this.featureName, promiseEE)
+
+    // register plugins
+    var pluginApi = {
+      getCurrentNode: getCurrentNode,
+      setCurrentNode: setCurrentNode
+    }
+
+    register('spa-register', function (init) {
+      if (typeof init === 'function') {
+        init(pluginApi)
+      }
+    }, FEATURE_NAMES.spa, baseEE)
+
+    function callbackStart () {
+      state.depth++
+      this.prevNode = state.currentNode
+      this.ct = state.childTime
+      state.childTime = 0
+      state.timerBudget = MAX_TIMER_BUDGET
+    }
+
+    register(FN_END, callbackEnd, this.featureName, baseEE)
+    register('cb-end', callbackEnd, this.featureName, promiseEE)
+
+    function callbackEnd () {
+      state.depth--
+      var totalTime = this.jsTime || 0
+      var exclusiveTime = totalTime - state.childTime
+      state.childTime = this.ct + totalTime
+      if (state.currentNode) {
+        // transfer accumulated callback time to the active interaction node
+        // run even if jsTime is 0 to update jsEnd
+        state.currentNode.callback(exclusiveTime, this[FN_END])
+        if (this.isTraced) {
+          state.currentNode.attrs.tracedTime = exclusiveTime
+        }
+      }
+
+      this.jsTime = state.currentNode ? 0 : exclusiveTime
+      setCurrentNode(this.prevNode)
+      this.prevNode = null
+      state.timerBudget = MAX_TIMER_BUDGET
+    }
+
+    register(FN_START, function (args, eventSource) {
+      var ev = args[0]
+      var evName = ev.type
+      var eventNode = ev.__nrNode
+
+      if (!state.pageLoaded && evName === 'load' && eventSource === window) {
+        state.pageLoaded = true
+        // set to null so prevNode is set correctly
+        this.prevNode = state.currentNode = null
+        if (state.initialPageLoad) {
+          eventNode = state.initialPageLoad.root
+
+          // Even if initialPageLoad has remaining callbacks, force the initialPageLoad
+          // interaction to complete when the page load event occurs.
+          state.initialPageLoad[REMAINING] = 0
+
+          originalSetTimeout(function () {
+            INTERACTION_EVENTS.push('popstate')
+          })
+        }
+      }
+
+      if (eventNode) {
+        // If we've already seen a previous handler for this specific event object,
+        // just restore that. We want multiple handlers for the same event to share
+        // a node.
+        setCurrentNode(eventNode)
+      } else if (evName === 'hashchange') {
+        setCurrentNode(state.nodeOnLastHashUpdate)
+        state.nodeOnLastHashUpdate = null
+      } else if (eventSource instanceof XMLHttpRequest) {
+        // If this event was emitted by an XHR, restore the node ID associated with
+        // that XHR.
+        setCurrentNode(baseEE.context(eventSource).spaNode)
+      } else if (!state.currentNode) {
+        // Otherwise, if no interaction is currently active, create a new node ID,
+        // and let the aggregator know that we entered a new event handler callback
+        // so that it has a chance to possibly start an interaction.
+        if (INTERACTION_EVENTS.indexOf(evName) !== -1) {
+          var ixn = new Interaction(evName, this[FN_START], state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier)
+
+          // Store the interaction as prevInteraction in case it is prematurely discarded
+          state.prevInteraction = ixn
+
+          setCurrentNode(ixn.root)
+
+          if (evName === 'click') {
+            var value = getActionText(ev.target)
+            if (value) {
+              state.currentNode.attrs.custom['actionText'] = value
+            }
+          }
+        }
+      }
+
+      ev.__nrNode = state.currentNode
+    }, this.featureName, eventsEE)
+
+    /**
+     * *** TIMERS ***
+     * setTimeout call needs to keep the interaction active in case a node is started
+     * in its callback.
+     */
+
+    // The context supplied to this callback will be shared with the fn-start/fn-end
+    // callbacks that fire around the callback passed to setTimeout originally.
+    register('setTimeout-end', function saveId (args, obj, timerId) {
+      if (!state.currentNode || (state.timerBudget - this.timerDuration) < 0) return
+      if (args && !(args[0] instanceof Function)) return
+      state.currentNode[INTERACTION][REMAINING]++
+      this.timerId = timerId
+      state.timerMap[timerId] = state.currentNode
+      this.timerBudget = state.timerBudget - 50
+    }, this.featureName, timerEE)
+
+    register('clearTimeout-start', function clear (args) {
+      var timerId = args[0]
+      var node = state.timerMap[timerId]
+      if (node) {
+        var interaction = node[INTERACTION]
+        interaction[REMAINING]--
+        interaction.checkFinish()
+        delete state.timerMap[timerId]
+      }
+    }, this.featureName, timerEE)
+
+    register(FN_START, function () {
+      state.timerBudget = this.timerBudget || MAX_TIMER_BUDGET
+      var id = this.timerId
+      var node = state.timerMap[id]
+      setCurrentNode(node)
+      delete state.timerMap[id]
+      if (node) node[INTERACTION][REMAINING]--
+    }, this.featureName, timerEE)
+
+    /**
+     * *** XHR ***
+     * - `new-xhr` event is fired when new instance of XHR is created. Here we create
+     *    a new node and store it on the XHR object.
+     * -  When the send method is called (`send-xhr-start` event), we tell the interaction
+     *    to wait for this XHR to complete.
+     * -  When any direct event handlers are invoked (`fn-start` on the `xhr` emitter),
+     *    we restore the node in case other child nodes are started here.
+     * -  Callbacks attached using `addEventListener` are handled using `fn-start` on the
+     *    `events` emitter.
+     * -  When `xhr-resolved` is emitted, we end the node. The node.finish() call also
+     *    instructs the interaction to stop waiting for this node.
+     */
+
+    // context is shared with new-xhr event, and is stored on the xhr iteself.
+    register(FN_START, function () {
+      setCurrentNode(this[SPA_NODE])
+    }, this.featureName, xhrEE)
+
+    // 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) {
+        /*
+         * The previous interaction was discarded before a route change. Restore the interaction
+         * in case this XHR is associated with a route change.
+         */
+        const interaction = state.prevInteraction
+        state.currentNode = interaction.root
+        interaction.root.end = null
+      }
+
+      if (state.currentNode) {
+        this[SPA_NODE] = state.currentNode.child('ajax', null, null, true)
+      }
+    }, this.featureName, xhrEE)
+
+    register('send-xhr-start', function () {
+      var node = this[SPA_NODE]
+      if (node && !this.sent) {
+        this.sent = true
+        node.dt = this.dt
+        node.jsEnd = node.start = this.startTime
+        node[INTERACTION][REMAINING]++
+      }
+    }, this.featureName, xhrEE)
+
+    register('xhr-resolved', function () {
+      var node = this[SPA_NODE]
+      if (node) {
+        if (!shouldCollectEvent(this.params)) {
+          node.cancel()
+          return
+        }
+
+        var attrs = node.attrs
+        attrs.params = this.params
+        attrs.metrics = this.metrics
+
+        node.finish(this.endTime)
+        if (!!this.currentNode && !!this.currentNode.interaction) this.currentNode.interaction.checkFinish()
+      }
+    }, this.featureName, baseEE)
+
+    /**
+     * *** JSONP ***
+     *
+     */
+
+    register('new-jsonp', function (url) {
+      if (state.currentNode) {
+        var node = this[JSONP_NODE] = state.currentNode.child('ajax', this[FETCH_START])
+        node.start = this['new-jsonp']
+        this.url = url
+        this.status = null
+      }
+    }, this.featureName, jsonpEE)
+
+    register('cb-start', function (args) {
+      var node = this[JSONP_NODE]
+      if (node) {
+        setCurrentNode(node)
+        this.status = 200
+      }
+    }, this.featureName, jsonpEE)
+
+    register('jsonp-error', function () {
+      var node = this[JSONP_NODE]
+      if (node) {
+        setCurrentNode(node)
+        this.status = 0
+      }
+    }, this.featureName, jsonpEE)
+
+    register(JSONP_END, function () {
+      var node = this[JSONP_NODE]
+      if (node) {
+        // if no status is set then cb never fired - so it's not a valid JSONP
+        if (this.status === null) {
+          node.cancel()
+          return
+        }
+        var attrs = node.attrs
+        var params = attrs.params = {}
+
+        var parsed = parseUrl(this.url)
+        params.method = 'GET'
+        params.pathname = parsed.pathname
+        params.host = parsed.hostname + ':' + parsed.port
+        params.status = this.status
+
+        attrs.metrics = {
+          txSize: 0,
+          rxSize: 0
+        }
+
+        attrs.isJSONP = true
+        node.jsEnd = this[JSONP_END]
+        node.jsTime = this[CB_START] ? (this[JSONP_END] - this[CB_START]) : 0
+        node.finish(node.jsEnd)
+      }
+    }, this.featureName, jsonpEE)
+
+    register(FETCH_START, function (fetchArguments, dtPayload) {
+      if (fetchArguments) {
+        if (!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.
+           */
+          const interaction = state.prevInteraction
+          state.currentNode = interaction.root
+          interaction.root.end = null
+        }
+
+        if (state.currentNode) {
+          this[SPA_NODE] = state.currentNode.child('ajax', this[FETCH_START])
+          if (dtPayload && this[SPA_NODE]) this[SPA_NODE].dt = dtPayload
+        }
+      }
+    }, this.featureName, fetchEE)
+
+    register(FETCH_BODY + 'start', function (args) {
+      if (state.currentNode) {
+        this[SPA_NODE] = state.currentNode
+        state.currentNode[INTERACTION][REMAINING]++
+      }
+    }, this.featureName, fetchEE)
+
+    register(FETCH_BODY + 'end', function (args, ctx, bodyPromise) {
+      var node = this[SPA_NODE]
+      if (node) node[INTERACTION][REMAINING]--
+    }, this.featureName, fetchEE)
+
+    register(FETCH_DONE, function (err, res) {
+      var node = this[SPA_NODE]
+      if (node) {
+        if (err) {
+          node.cancel()
+          return
+        }
+
+        var attrs = node.attrs
+        attrs.params = this.params
+        attrs.metrics = {
+          txSize: this.txSize,
+          rxSize: this.rxSize
+        }
+        attrs.isFetch = true
+
+        node.finish(this[FETCH_DONE])
+      }
+    }, this.featureName, fetchEE)
+
+    register('newURL', function (url, hashChangedDuringCb) {
+      if (state.currentNode) {
+        state.currentNode[INTERACTION].setNewURL(url)
+      } else if (state.prevInteraction && !state.prevInteraction.ignored) {
+        /*
+         * The previous interaction was discarded before the route was changed. This can happen in SPA
+         * frameworks when using lazy loading. We have also seen this in version 11+ of Nextjs where
+         * some route changes re-use cached resolved promises.
+         */
+        const interaction = state.prevInteraction
+        interaction.setNewURL(url)
+        interaction.root.end = null
+
+        setCurrentNode(interaction.root)
+      }
+
+      if (state.currentNode) {
+        if (state.lastSeenUrl !== url) {
+          state.currentNode[INTERACTION].routeChange = true
+        }
+        if (hashChangedDuringCb) {
+          state.nodeOnLastHashUpdate = state.currentNode
+        }
+      }
+
+      state.lastSeenUrl = url
+    }, this.featureName, historyEE)
+
+    /**
+     * SCRIPTS
+     *   This is only needed to keep the interaction open while external scripts are being loaded.
+     *   The script that is loaded could continue the interaction by making additional AJAX
+     *   calls or changing the URL. The interaction context (currentNode) needs to be
+     *   restored somehow, but this differs based on the specific customer code. In some cases, we
+     *   could wrap a JSONP callback, in other cases we could wrap a higher-level API, and in
+     *   some cases we may not be able to restore context automatically (customer would need
+     *   to instrument their code manually).
+     *
+     * - We do not restore the original context in the load/error callbacks. This would not
+     *   work for the scripts themselves because by the time the load event fires, the
+     *   script content has already been executed.
+     */
+
+    // dom-start is emitted when appendChild or replaceChild are called. If the element being
+    // inserted is script and we are inside an interaction, we will keep the interaction open
+    // until the script is loaded.
+    jsonpEE.on('dom-start', function (args) {
+      if (!state.currentNode) return
+
+      var el = args[0]
+      var isScript = (el && el.nodeName === 'SCRIPT' && el.src !== '')
+      var interaction = state.currentNode.interaction
+
+      if (isScript) {
+        // increase remaining count to keep the interaction open
+        interaction[REMAINING]++
+        el.addEventListener('load', onload, eventListenerOpts(false))
+        el.addEventListener('error', onerror, eventListenerOpts(false))
+      }
+
+      function onload () {
+        // decrease remaining to allow interaction to finish
+        interaction[REMAINING]--
+
+        // checkFinish is what initiates closing interaction, but is only called
+        // when setCurrentNode is called. Since we are not restoring a node here,
+        // we need to initiate the check manually.
+        // The reason we are not restoring the node here is because 1) this is not
+        // where the code of the external script runs (by the time the load event
+        // fires, it has already executed), and 2) it would require storing the context
+        // probably on the DOM node and restoring in all callbacks, which is a different
+        // use case than lazy loading.
+        interaction.checkFinish()
+      }
+
+      function onerror () {
+        interaction[REMAINING]--
+        interaction.checkFinish()
+      }
+    })
+
+    register(FN_START, function () {
+      setCurrentNode(state.prevNode)
+    }, this.featureName, mutationEE)
+
+    register('resolve-start', resolvePromise, this.featureName, promiseEE)
+    register('executor-err', resolvePromise, this.featureName, promiseEE)
+
+    register('propagate', saveNode, this.featureName, promiseEE)
+
+    register(CB_START, function () {
+      var ctx = this.getCtx ? this.getCtx() : this
+      setCurrentNode(ctx[SPA_NODE])
+    }, this.featureName, promiseEE)
+
+    register(INTERACTION_API + 'get', function (t) {
+      var interaction
+      if (state?.currentNode?.[INTERACTION]) interaction = this.ixn = state.currentNode[INTERACTION]
+      else if (state?.prevNode?.end === null && state?.prevNode?.[INTERACTION]?.root?.[INTERACTION]?.eventName != 'initialPageLoad') interaction = this.ixn = state.prevNode[INTERACTION]
+      else interaction = this.ixn = new Interaction('api', t, state.lastSeenUrl, state.lastSeenRouteName, onInteractionFinished, agentIdentifier)
+      if (!state.currentNode) {
+        interaction.checkFinish()
+        if (state.depth) setCurrentNode(interaction.root)
+      }
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'actionText', function (t, actionText) {
+      var customAttrs = this.ixn.root.attrs.custom
+      if (actionText) customAttrs.actionText = actionText
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'setName', function (t, name, trigger) {
+      var attrs = this.ixn.root.attrs
+      if (name) attrs.customName = name
+      if (trigger) attrs.trigger = trigger
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'setAttribute', function (t, name, value) {
+      this.ixn.root.attrs.custom[name] = value
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'end', function (timestamp) {
+      var interaction = this.ixn
+      var node = activeNodeFor(interaction)
+      setCurrentNode(null)
+      node.child('customEnd', timestamp).finish(timestamp)
+      interaction.finish()
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'ignore', function (t) {
+      this.ixn.ignored = true
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'save', function (t) {
+      this.ixn.save = true
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'tracer', function (timestamp, name, store) {
+      var interaction = this.ixn
+      var parent = activeNodeFor(interaction)
+      var ctx = baseEE.context(store)
+      if (!name) {
+        ctx.inc = ++interaction[REMAINING]
+
+        return (ctx[SPA_NODE] = parent)
+      }
+      ctx[SPA_NODE] = parent.child('customTracer', timestamp, name)
+    }, this.featureName, baseEE)
+
+    register(FN_START, tracerDone, this.featureName, tracerEE)
+    register('no-' + FN_START, tracerDone, this.featureName, tracerEE)
+
+    function tracerDone (timestamp, interactionContext, hasCb) {
+      var node = this[SPA_NODE]
+      if (!node) return
+      var interaction = node[INTERACTION]
+      var inc = this.inc
+      this.isTraced = true
+      if (inc) {
+        interaction[REMAINING]--
+      } else if (node) {
+        node.finish(timestamp)
+      }
+      hasCb ? setCurrentNode(node) : interaction.checkFinish()
+    }
+
+    register(INTERACTION_API + 'getContext', function (t, cb) {
+      var store = this.ixn.root.attrs.store
+      setTimeout(function () {
+        cb(store)
+      }, 0)
+    }, this.featureName, baseEE)
+
+    register(INTERACTION_API + 'onEnd', function (t, cb) {
+      this.ixn.handlers.push(cb)
+    }, this.featureName, baseEE)
+
+    register('api-routeName', function (t, currentRouteName) {
+      state.lastSeenRouteName = currentRouteName
+      if (state.currentNode) state.currentNode[INTERACTION].setNewRoute(currentRouteName)
+    }, this.featureName, baseEE)
+
+    function activeNodeFor (interaction) {
+      return (state.currentNode && state.currentNode[INTERACTION] === interaction) ? state.currentNode : interaction.root
+    }
+
+    function saveNode (val, overwrite) {
+      if (overwrite || !this[SPA_NODE]) this[SPA_NODE] = state.currentNode
+    }
+
+    function resolvePromise () {
+      if (!this.resolved) {
+        this.resolved = true
+        this[SPA_NODE] = state.currentNode
+      }
+    }
+
+    function getCurrentNode () {
+      return state.currentNode
+    }
+
+    function setCurrentNode (newNode) {
+      if (!state.pageLoaded && !newNode && state.initialPageLoad) newNode = state.initialPageLoad.root
+      if (state.currentNode) {
+        state.currentNode[INTERACTION].checkFinish()
+      }
+
+      state.prevNode = state.currentNode
+      state.currentNode = (newNode && !newNode[INTERACTION].root.end) ? newNode : null
+    }
+
+    function onInteractionFinished (interaction) {
+      if (interaction === state.initialPageLoad) state.initialPageLoad = null
+
+      var root = interaction.root
+      var attrs = root.attrs
+
+      // make sure that newrelic[INTERACTION]() works in end handler
+      state.currentNode = root
+      mapOwn(interaction.handlers, function (i, cb) {
+        cb(attrs.store)
+      })
+      setCurrentNode(null)
+    }
+
+    function onHarvestStarted (options) {
+      if (state.interactionsToHarvest.length === 0 || blocked) return {}
+      var payload = serializer.serializeMultiple(state.interactionsToHarvest, 0, navTiming)
+
+      if (options.retry) {
+        state.interactionsToHarvest.forEach(function (interaction) {
+          state.interactionsSent.push(interaction)
+        })
+      }
+      state.interactionsToHarvest = []
+
+      return { body: { e: payload } }
+    }
+
+    function onHarvestFinished (result) {
+      if (result.sent && result.retry && state.interactionsSent.length > 0) {
+        state.interactionsSent.forEach(function (interaction) {
+          state.interactionsToHarvest.push(interaction)
+        })
+        state.interactionsSent = []
+      }
+    }
+
+    baseEE.on('errorAgg', function (type, name, params, metrics) {
+      if (!state.currentNode) return
+      params._interactionId = state.currentNode.interaction.id
+      // do not capture parentNodeId when in root node
+      if (state.currentNode.type && state.currentNode.type !== 'interaction') {
+        params._interactionNodeId = state.currentNode.id
+      }
+    })
+
+    baseEE.on('interaction', saveInteraction)
+
+    function getActionText (node) {
+      var nodeType = node.tagName.toLowerCase()
+      var goodNodeTypes = ['a', 'button', 'input']
+      var isGoodNode = goodNodeTypes.indexOf(nodeType) !== -1
+      if (isGoodNode) {
+        return node.title || node.value || node.innerText
+      }
+    }
+
+    function saveInteraction (interaction) {
+      if (interaction.ignored || (!interaction.save && !interaction.routeChange)) {
+        baseEE.emit('interactionDiscarded', [interaction])
+        return
+      }
+
+      if (state.prevInteraction === interaction) {
+        // If the interaction is being saved, remove it from prevInteraction variable
+        // to prevent the interaction from possibly being sent twice or causing an internal
+        // recursive loop issue.
+        state.prevInteraction = null
+      }
+
+      // assign unique id, this is serialized and used to link interactions with errors
+      interaction.root.attrs.id = generateUuid()
+
+      if (interaction.root.attrs.trigger === 'initialPageLoad') {
+        interaction.root.attrs.firstPaint = paintMetrics['first-paint']
+        interaction.root.attrs.firstContentfulPaint = paintMetrics['first-contentful-paint']
+      }
+      baseEE.emit('interactionSaved', [interaction])
+      state.interactionsToHarvest.push(interaction)
+      scheduler.scheduleHarvest(0)
+    }
+
+    function isEnabled () {
+      var enabled = getConfigurationValue(agentIdentifier, 'spa.enabled')
+      if (enabled === false) {
+        return false
+      }
+      return true
+    }
+
+    drain(this.agentIdentifier, this.featureName)
+  }
+}