feat: Calculate New Relic time in the agent (#911)

Author: patrickhousley

src/cdn/polyfills.js

@@ -22,3 +22,4 @@ 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'
+import 'core-js/stable/number/is-nan'

src/common/context/observation-context-manager.js

@@ -6,9 +6,11 @@
 import { gosNREUM } from '../window/nreum'
 import { getOrSet } from '../util/get-or-set'
 import { getRuntime } from '../config/config'
-import { EventContext } from '../context/event-context'
-import { ObservationContextManager } from '../context/observation-context-manager'
+import { EventContext } from './event-context'
+import { bundleId } from '../ids/bundle-id'
 
+// create a unique id to store event context data for the current agent bundle
+const contextId = `nr@context:${bundleId}`
 // create global emitter instance that can be shared among bundles
 const globalInstance = ee(undefined, 'globalEE')
 
@@ -18,7 +20,7 @@ if (!nr.ee) {
   nr.ee = globalInstance
 }
 
-export { globalInstance as ee }
+export { globalInstance as ee, contextId }
 
 function ee (old, debugId) {
   var handlers = {}
@@ -50,8 +52,8 @@ function ee (old, debugId) {
     aborted: false,
     isBuffering,
     debugId,
-    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {},
-    observationContextManager: null
+    backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
+
   }
 
   return emitter
@@ -60,15 +62,9 @@ function ee (old, debugId) {
     if (contextOrStore && contextOrStore instanceof EventContext) {
       return contextOrStore
     } else if (contextOrStore) {
-      return getOrSet(contextOrStore, ObservationContextManager.contextId, () =>
-        emitter.observationContextManager
-          ? emitter.observationContextManager.getCreateContext(contextOrStore)
-          : new EventContext(ObservationContextManager.contextId)
-      )
+      return getOrSet(contextOrStore, contextId, () => new EventContext(contextId))
     } else {
-      return emitter.observationContextManager
-        ? emitter.observationContextManager.getCreateContext({})
-        : new EventContext(ObservationContextManager.contextId)
+      return new EventContext(contextId)
     }
   }
 
@@ -116,13 +112,7 @@ function ee (old, debugId) {
   }
 
   function getOrCreate (name) {
-    const newEventEmitter = (emitters[name] = emitters[name] || ee(emitter, name))
-
-    if (!newEventEmitter.observationContextManager && emitter.observationContextManager) {
-      newEventEmitter.observationContextManager = emitter.observationContextManager
-    }
-
-    return newEventEmitter
+    return (emitters[name] = emitters[name] || ee(emitter, name))
   }
 
   function bufferEventsByGroup (types, group) {

src/common/event-emitter/contextual-ee.js

@@ -145,7 +145,7 @@ export class Harvest extends SharedContext {
       result.addEventListener('loadend', function () {
         // `this` refers to the XHR object in this scope, do not change this to a fat arrow
         // status 0 refers to a local error, such as CORS or network failure, or a blocked request by the browser (e.g. adblocker)
-        const cbResult = { sent: this.status !== 0, status: this.status }
+        const cbResult = { sent: this.status !== 0, status: this.status, xhr: this, fullUrl }
         if (this.status === 429) {
           cbResult.retry = true
           cbResult.delay = harvestScope.tooManyRequestsDelay

src/common/context/event-context.js renamed to src/common/event-emitter/event-context.js

@@ -368,7 +368,7 @@ describe('_send', () => {
     expect(xhrAddEventListener).toHaveBeenCalledWith('loadend', expect.any(Function), expect.any(Object))
     expect(result).toEqual(jest.mocked(submitDataModule.xhr).mock.results[0].value)
     expect(submitMethod).not.toHaveBeenCalled()
-    expect(spec.cbFinished).toHaveBeenCalledWith({ ...xhrState, sent: true })
+    expect(spec.cbFinished).toHaveBeenCalledWith({ ...xhrState, sent: true, xhr: xhrState, fullUrl: expect.any(String) })
   })
 
   test('should set cbFinished state retry to true with delay when xhr has 429 status', () => {
@@ -392,7 +392,9 @@ describe('_send', () => {
       ...xhrState,
       sent: true,
       retry: true,
-      delay: harvestInstance.tooManyRequestsDelay
+      delay: harvestInstance.tooManyRequestsDelay,
+      xhr: xhrState,
+      fullUrl: expect.any(String)
     })
   })
 
@@ -417,7 +419,9 @@ describe('_send', () => {
     expect(spec.cbFinished).toHaveBeenCalledWith({
       ...xhrState,
       sent: true,
-      retry: true
+      retry: true,
+      xhr: xhrState,
+      fullUrl: expect.any(String)
     })
   })
 
@@ -441,7 +445,9 @@ describe('_send', () => {
     expect(submitMethod).not.toHaveBeenCalled()
     expect(spec.cbFinished).toHaveBeenCalledWith({
       ...xhrState,
-      sent: true
+      sent: true,
+      xhr: xhrState,
+      fullUrl: expect.any(String)
     })
   })
 
@@ -466,7 +472,9 @@ describe('_send', () => {
     expect(spec.cbFinished).toHaveBeenCalledWith({
       ...xhrState,
       responseText: undefined,
-      sent: true
+      sent: true,
+      xhr: xhrState,
+      fullUrl: expect.any(String)
     })
   })
 
@@ -488,7 +496,9 @@ describe('_send', () => {
     expect(submitMethod).not.toHaveBeenCalled()
     expect(spec.cbFinished).toHaveBeenCalledWith({
       ...xhrState,
-      sent: false
+      sent: false,
+      xhr: xhrState,
+      fullUrl: expect.any(String)
     })
   })
 })

src/common/harvest/harvest.js

@@ -0,0 +1,96 @@
+import { gosNREUM } from '../window/nreum'
+import { globalScope } from '../constants/runtime'
+import { getRuntime } from '../config/config'
+
+/**
+ * Class used to adjust the timestamp of harvested data to New Relic server time. This
+ * is done by tracking the performance timings of the RUM call and applying a calculation
+ * to the harvested data event offset time.
+ */
+export class TimeKeeper {
+  #agent
+
+  /**
+   * Represents the browser origin time corrected to NR server time.
+   * @type {number}
+   */
+  #correctedOriginTime
+
+  /**
+   * Represents the difference in milliseconds between the calculated NR server time and
+   * the local time.
+   * @type {number}
+   */
+  #localTimeDiff
+
+  constructor (agent) {
+    this.#agent = agent
+  }
+
+  static getTimeKeeperByAgentIdentifier (agentIdentifier) {
+    const nr = gosNREUM()
+    return Object.keys(nr?.initializedAgents || {}).indexOf(agentIdentifier) > -1
+      ? nr.initializedAgents[agentIdentifier].timeKeeper
+      : undefined
+  }
+
+  get correctedPageOriginTime () {
+    return this.#correctedOriginTime
+  }
+
+  /**
+   * Process a rum request to calculate NR server time.
+   * @param rumRequest {XMLHttpRequest} The xhr for the rum request
+   * @param rumRequestUrl {string} The full url of the rum request
+   */
+  processRumRequest (rumRequest, rumRequestUrl) {
+    const responseDateHeader = rumRequest.getResponseHeader('Date')
+    if (!responseDateHeader) {
+      throw new Error('Missing date header on rum response.')
+    }
+
+    const resourceEntries = globalScope.performance.getEntriesByName(rumRequestUrl, 'resource')
+    if (!Array.isArray((resourceEntries)) || resourceEntries.length === 0) {
+      throw new Error('Missing rum request performance entry.')
+    }
+
+    let medianRumOffset = 0
+    let serverOffset = 0
+    if (typeof resourceEntries[0].responseStart === 'number' && resourceEntries[0].responseStart !== 0) {
+      // Cors is enabled and we can make a more accurate calculation of NR server time
+      medianRumOffset = (resourceEntries[0].responseStart - resourceEntries[0].requestStart) / 2
+      serverOffset = Math.floor(resourceEntries[0].requestStart + medianRumOffset)
+    } else {
+      // Cors is disabled or erred, we need to use a less accurate calculation
+      medianRumOffset = (resourceEntries[0].responseEnd - resourceEntries[0].fetchStart) / 2
+      serverOffset = Math.floor(resourceEntries[0].fetchStart + medianRumOffset)
+    }
+
+    // Corrected page origin time
+    this.#correctedOriginTime = Math.floor(Date.parse(responseDateHeader) - serverOffset)
+    this.#localTimeDiff = getRuntime(this.#agent.agentIdentifier).offset - this.#correctedOriginTime
+
+    if (Number.isNaN(this.#correctedOriginTime)) {
+      throw new Error('Date header invalid format.')
+    }
+  }
+
+  /**
+   * Converts a page origin relative time to an absolute timestamp
+   * corrected to NR server time.
+   * @param relativeTime {number} The relative time of the event in milliseconds
+   * @returns {number} The correct timestamp as a unix/epoch timestamp value
+   */
+  convertRelativeTimestamp (relativeTime) {
+    return this.#correctedOriginTime + relativeTime
+  }
+
+  /**
+   * Corrects an event timestamp to NR server time.
+   * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
+   * @return {number} Corrected unix/epoch timestamp
+   */
+  correctAbsoluteTimestamp (timestamp) {
+    return Math.floor(timestamp - this.#localTimeDiff)
+  }
+}