@newrelic/browser-agent 1.233.1 → 1.235.0

package/src/common/harvest/harvest.component-test.js

@@ -0,0 +1,169 @@
+import { submitData } from '../util/submit-data'
+import { Harvest } from './harvest'
+
+jest.mock('../context/shared-context', () => ({
+  __esModule: true,
+  SharedContext: function () {
+    this.sharedContext = {
+      agentIdentifier: 'abcd'
+    }
+  }
+}))
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  getConfigurationValue: jest.fn(),
+  getInfo: jest.fn().mockReturnValue({
+    errorBeacon: 'example.com',
+    licenseKey: 'abcd'
+  }),
+  getRuntime: jest.fn().mockReturnValue({
+    bytesSent: {},
+    queryBytesSent: {}
+  })
+}))
+jest.mock('../util/submit-data', () => ({
+  __esModule: true,
+  submitData: {
+    xhr: jest.fn(() => ({
+      addEventListener: jest.fn()
+    })),
+    beacon: jest.fn(),
+    img: jest.fn()
+  }
+}))
+
+describe('sendX', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', (sendEmptyBody) => {
+    const sendCallback = jest.fn()
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', cbFinished: sendCallback })
+
+    expect(sendCallback).toHaveBeenCalledWith({ sent: false })
+    expect(submitData.xhr).not.toHaveBeenCalled()
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: {},
+      qs: {}
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', opts: { sendEmptyBody: true }, cbFinished: jest.fn() })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/jserrors/1/abcd?'),
+      body: undefined
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', (emptyValue) => {
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: { bar: 'foo', empty: emptyValue },
+      qs: { foo: 'bar', empty: emptyValue }
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', cbFinished: jest.fn() })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({ bar: 'foo' })
+    }))
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', (nonStringValue) => {
+    const harvester = new Harvest()
+    harvester.on('jserrors', () => ({
+      body: { bar: 'foo', nonString: nonStringValue },
+      qs: { foo: 'bar', nonString: nonStringValue }
+    }))
+
+    harvester.sendX({ endpoint: 'jserrors', cbFinished: jest.fn() })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining(`&nonString=${nonStringValue}`),
+      body: JSON.stringify({ bar: 'foo', nonString: nonStringValue })
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+})
+
+describe('send', () => {
+  test.each([null, undefined, false])('should not send request when body is empty and sendEmptyBody is %s', (sendEmptyBody) => {
+    const sendCallback = jest.fn()
+    const harvester = new Harvest()
+
+    harvester.send({ endpoint: 'rum', payload: { qs: {}, body: {} }, opts: { sendEmptyBody }, cbFinished: sendCallback })
+
+    expect(sendCallback).toHaveBeenCalledWith({ sent: false })
+    expect(submitData.xhr).not.toHaveBeenCalled()
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test('should send request when body is empty and sendEmptyBody is true', () => {
+    const harvester = new Harvest()
+
+    harvester.send({ endpoint: 'rum', payload: { qs: {}, body: {} }, opts: { sendEmptyBody: true } })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('https://example.com/1/abcd?'),
+      body: undefined
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([null, undefined, []])('should remove %s values from the body and query string when sending', (emptyValue) => {
+    const harvester = new Harvest()
+
+    harvester.send({
+      endpoint: 'rum',
+      payload: { qs: { foo: 'bar', empty: emptyValue }, body: { bar: 'foo', empty: emptyValue } }
+    })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining('&foo=bar'),
+      body: JSON.stringify({ bar: 'foo' })
+    }))
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.not.stringContaining('&empty'),
+      body: expect.not.stringContaining('empty')
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+
+  test.each([1, false, true])('should not remove value %s (when it doesn\'t have a length) from the body and query string when sending', (nonStringValue) => {
+    const harvester = new Harvest()
+
+    harvester.send({
+      endpoint: 'rum',
+      payload: { qs: { foo: 'bar', nonString: nonStringValue }, body: { bar: 'foo', nonString: nonStringValue } }
+    })
+
+    expect(submitData.xhr).toHaveBeenCalledWith(expect.objectContaining({
+      url: expect.stringContaining(`&nonString=${nonStringValue}`),
+      body: JSON.stringify({ bar: 'foo', nonString: nonStringValue })
+    }))
+    expect(submitData.img).not.toHaveBeenCalled()
+    expect(submitData.beacon).not.toHaveBeenCalled()
+  })
+})

package/src/common/harvest/harvest.js

@@ -98,7 +98,7 @@ export class Harvest extends SharedContext {
 
     var agentRuntime = getRuntime(this.sharedContext.agentIdentifier)
 
-    if (!payload.body) { // no payload body? nothing to send, just run onfinish stuff and return
+    if (!payload.body && !opts?.sendEmptyBody) { // no payload body? nothing to send, just run onfinish stuff and return
       if (cbFinished) {
         cbFinished({ sent: false })
       }
@@ -108,7 +108,7 @@ export class Harvest extends SharedContext {
     let url = ''
     if (customUrl) url = customUrl
     else if (raw) url = `${this.getScheme()}://${info.errorBeacon}/${endpoint}`
-    else url = `${this.getScheme()}://${info.errorBeacon}/${endpoint}/1/${info.licenseKey}`
+    else url = `${this.getScheme()}://${info.errorBeacon}${endpoint !== 'rum' ? `/${endpoint}` : ''}/1/${info.licenseKey}`
 
     var baseParams = !raw && includeBaseParams ? this.baseQueryString() : ''
     var payloadParams = payload.qs ? encodeObj(payload.qs, agentRuntime.maxBytes) : ''
@@ -208,6 +208,7 @@ export class Harvest extends SharedContext {
       if (singlePayload.body) mapOwn(singlePayload.body, makeBody)
       if (singlePayload.qs) mapOwn(singlePayload.qs, makeQueryString)
     }
+
     return { body: makeBody(), qs: makeQueryString() }
   }
 
@@ -223,17 +224,12 @@ export class Harvest extends SharedContext {
   }
 }
 
-function or (a, b) { return a || b }
-
 export function getSubmitMethod (endpoint, opts) {
   opts = opts || {}
   var method
   var useBody
 
-  if (opts.needResponse) { // currently: only STN needs a response
-    useBody = true
-    method = submitData.xhr
-  } else if (opts.unload && isBrowserScope) { // all the features' final harvest; neither methods work outside window context
+  if (opts.unload && isBrowserScope) { // all the features' final harvest; neither methods work outside window context
     useBody = haveSendBeacon
     method = haveSendBeacon ? submitData.beacon : submitData.img // really only IE doesn't have Beacon API for web browsers
   } else {
@@ -263,7 +259,7 @@ function createAccumulator () {
   var accumulator = {}
   var hasData = false
   return function (key, val) {
-    if (val !== null && val !== undefined && val.length) {
+    if (val !== null && val !== undefined && val.toString()?.length) {
       accumulator[key] = val
       hasData = true
     }

package/src/common/session/{session-entity.test.js → session-entity.component-test.js}

@@ -1,13 +1,39 @@
-
-import { LocalMemory } from '../storage/local-memory'
-import { LocalStorage } from '../storage/local-storage'
-
 import { PREFIX } from './constants'
 import { SessionEntity } from './session-entity'
 
 const agentIdentifier = 'test_agent_identifier'
 const key = 'test_key'
 const value = 'test_value'
+class LocalMemory {
+  constructor (initialState = {}) {
+    this.state = initialState
+  }
+
+  get (key) {
+    try {
+      return this.state[key]
+    } catch (err) {
+      return ''
+    }
+  }
+
+  set (key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key)
+      this.state[key] = value
+    } catch (err) {
+      return
+    }
+  }
+
+  remove (key) {
+    try {
+      delete this.state[key]
+    } catch (err) {
+      return
+    }
+  }
+}
 
 jest.mock('../timer/timer')
 jest.mock('../timer/interaction-timer')
@@ -24,9 +50,11 @@ jest.mock('../util/global-scope', () => ({
   }
 }))
 
+let storage
 beforeEach(() => {
   jest.restoreAllMocks()
   mockBrowserScope.mockReturnValue(true)
+  storage = new LocalMemory()
 })
 
 describe('constructor', () => {
@@ -37,7 +65,7 @@ describe('constructor', () => {
   })
 
   test('top-level properties are set and exposed', () => {
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session).toMatchObject({
       agentIdentifier: expect.any(String),
       key: expect.any(String),
@@ -52,119 +80,113 @@ describe('constructor', () => {
         expiresAt: expect.any(Number),
         inactiveAt: expect.any(Number),
         sessionReplay: expect.any(Number),
-        sessionTraceActive: expect.any(Boolean)
+        sessionTraceMode: expect.any(Number)
       })
     })
   })
 
   test('can use sane defaults', () => {
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
       updatedAt: expect.any(Number),
       sessionReplay: expect.any(Number),
-      sessionTraceActive: expect.any(Boolean)
+      sessionTraceMode: expect.any(Number)
     }))
   })
 
-  test('Workers are forced to use local memory', () => {
-    mockBrowserScope.mockReturnValueOnce(false)
-    const session = new SessionEntity({ agentIdentifier, key, storageAPI: new LocalStorage() })
-    expect(session.storage instanceof LocalMemory).toEqual(true)
-  })
-
   test('expiresAt is the correct future timestamp - new session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 100 })
     expect(session.state.expiresAt).toEqual(now + 100)
   })
 
   test('expiresAt is the correct future timestamp - existing session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceActive: false, custom: {} } })
-    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100, storageAPI: existingData })
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now + 5000, inactiveAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
+    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 100, storage: existingData })
     expect(session.state.expiresAt).toEqual(now + 5000)
   })
 
   test('expiresAt never expires if 0', () => {
-    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 0 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 0 })
     expect(session.state.expiresAt).toEqual(Infinity)
   })
 
   test('inactiveAt is the correct future timestamp - new session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, inactiveMs: 100 })
     expect(session.state.inactiveAt).toEqual(now + 100)
   })
 
   test('inactiveAt is the correct future timestamp - existing session', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceActive: false, custom: {} } })
-    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100, storageAPI: existingData })
+    const existingData = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now + 5000, expiresAt: Infinity, updatedAt: now, sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
+    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100, storage: existingData })
     expect(session.state.inactiveAt).toEqual(now + 5000)
   })
 
   test('inactiveAt never expires if 0', () => {
-    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 0 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, inactiveMs: 0 })
     expect(session.state.inactiveAt).toEqual(Infinity)
   })
 
   test('should handle isNew', () => {
-    const newSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    const newSession = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
     expect(newSession.isNew).toBeTruthy()
 
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceActive: false, custom: {} } })
-    const existingSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10, storageAPI })
+    const newStorage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
+    const existingSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10, storage: newStorage })
     expect(existingSession.isNew).toBeFalsy()
   })
 
   test('invalid stored values sets new defaults', () => {
     // missing required fields
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { invalid_fields: true } })
-    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { invalid_fields: true } })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
       updatedAt: expect.any(Number),
       sessionReplay: expect.any(Number),
-      sessionTraceActive: expect.any(Boolean)
+      sessionTraceMode: expect.any(Number)
     }))
   })
 
   test('expired expiresAt value in storage sets new defaults', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now - 100, inactiveAt: Infinity } })
-    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: now - 100, inactiveAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
       updatedAt: expect.any(Number),
       sessionReplay: expect.any(Number),
-      sessionTraceActive: expect.any(Boolean)
+      sessionTraceMode: expect.any(Number)
     }))
   })
 
   test('expired inactiveAt value in storage sets new defaults', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now - 100, expiresAt: Infinity } })
-    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, inactiveAt: now - 100, expiresAt: Infinity } })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session.state).toEqual(expect.objectContaining({
       value: expect.any(String),
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
       updatedAt: expect.any(Number),
       sessionReplay: expect.any(Number),
-      sessionTraceActive: expect.any(Boolean)
+      sessionTraceMode: expect.any(Number)
     }))
   })
 })
@@ -173,7 +195,7 @@ describe('reset()', () => {
   test('should create new default values when resetting', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
     const sessionVal = session.value
     expect(session.state.value).toBeTruthy()
     session.reset()
@@ -184,7 +206,7 @@ describe('reset()', () => {
   test('custom data should be wiped on reset', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
     session.syncCustomAttribute('test', 123)
     expect(session.state.custom.test).toEqual(123)
     expect(session.read().custom.test).toEqual(123)
@@ -198,7 +220,7 @@ describe('reset()', () => {
 
 describe('read()', () => {
   test('"new" sessions get data from read()', () => {
-    const newSession = new SessionEntity({ agentIdentifier, key, expiresMs: 10 })
+    const newSession = new SessionEntity({ agentIdentifier, key, storage, expiresMs: 10 })
     expect(newSession.isNew).toBeTruthy()
 
     expect(newSession.read()).toEqual(expect.objectContaining({
@@ -206,13 +228,13 @@ describe('read()', () => {
       expiresAt: expect.any(Number),
       inactiveAt: expect.any(Number),
       sessionReplay: expect.any(Number),
-      sessionTraceActive: expect.any(Boolean)
+      sessionTraceMode: expect.any(Number)
     }))
   })
 
   test('"pre-existing" sessions get data from read()', () => {
-    const storageAPI = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceActive: false, custom: {} } })
-    const session = new SessionEntity({ agentIdentifier, key, storageAPI })
+    const storage = new LocalMemory({ [`${PREFIX}_${key}`]: { value, expiresAt: Infinity, inactiveAt: Infinity, updatedAt: Date.now(), sessionReplay: 0, sessionTraceMode: 0, custom: {} } })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session.isNew).toBeFalsy()
     expect(session.read()).toEqual(expect.objectContaining({
       value,
@@ -224,7 +246,7 @@ describe('read()', () => {
 
 describe('write()', () => {
   test('write() sets data to top-level wrapper', () => {
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     expect(session.state.value).not.toEqual(value)
     expect(session.state.expiresAt).not.toEqual(Infinity)
     expect(session.state.inactiveAt).not.toEqual(Infinity)
@@ -237,7 +259,7 @@ describe('write()', () => {
   test('write() sets data that read() can access', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     session.write({ ...session.state, value, expiresAt: now + 100, inactiveAt: now + 100 })
     const read = session.read()
     expect(read.value).toEqual(value)
@@ -246,7 +268,7 @@ describe('write()', () => {
   })
 
   test('write() does not run with invalid data', () => {
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     let out = session.write()
     expect(out).toEqual(undefined)
     out = session.write('string')
@@ -264,7 +286,7 @@ describe('refresh()', () => {
   test('refresh sets inactiveAt to future time', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, inactiveMs: 100 })
+    const session = new SessionEntity({ agentIdentifier, key, storage, inactiveMs: 100 })
     expect(session.state.inactiveAt).toEqual(now + 100)
     jest.setSystemTime(now + 1000)
     session.refresh()
@@ -274,7 +296,7 @@ describe('refresh()', () => {
   test('refresh resets the entity if expiresTimer is invalid', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, value })
+    const session = new SessionEntity({ agentIdentifier, key, storage, value })
     expect(session.state.value).toEqual(value)
     session.write({ ...session.state, expiresAt: now - 1 })
     session.refresh()
@@ -284,7 +306,7 @@ describe('refresh()', () => {
   test('refresh resets the entity if inactiveTimer is invalid', () => {
     const now = Date.now()
     jest.setSystemTime(now)
-    const session = new SessionEntity({ agentIdentifier, key, value })
+    const session = new SessionEntity({ agentIdentifier, key, storage, value })
     expect(session.state.value).toEqual(value)
     session.write({ ...session.state, inactiveAt: now - 1 })
     session.refresh()
@@ -294,7 +316,7 @@ describe('refresh()', () => {
 
 describe('syncCustomAttribute()', () => {
   test('Custom data can be managed by session entity', () => {
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
 
     // if custom has never been set, and a "delete" action is triggered, do nothing
     session.syncCustomAttribute('test', null)
@@ -316,7 +338,7 @@ describe('syncCustomAttribute()', () => {
 
   test('Only runs in browser scope', () => {
     mockBrowserScope.mockReturnValue(false)
-    const session = new SessionEntity({ agentIdentifier, key })
+    const session = new SessionEntity({ agentIdentifier, key, storage })
     session.syncCustomAttribute('test', 1)
     expect(session.read().custom?.test).toEqual(undefined)
   })

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

@@ -5,7 +5,6 @@ import { ee } from '../event-emitter/contextual-ee'
 import { Timer } from '../timer/timer'
 import { isBrowserScope } from '../util/global-scope'
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, PREFIX } from './constants'
-import { LocalMemory } from '../storage/local-memory'
 import { InteractionTimer } from '../timer/interaction-timer'
 import { wrapEvents } from '../wrap'
 import { getModeledObject } from '../config/state/configurable'
@@ -13,6 +12,11 @@ import { handle } from '../event-emitter/handle'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
 import { FEATURE_NAMES } from '../../loaders/features/features'
 
+export const MODE = {
+  OFF: 0,
+  FULL: 1,
+  ERROR: 2
+}
 // this is what can be stored in local storage (not enforced but probably should be)
 // these values should sync between local storage and the parent class props
 const model = {
@@ -20,11 +24,10 @@ const model = {
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplay: 0,
-  sessionTraceActive: false,
+  sessionReplay: MODE.OFF,
+  sessionTraceMode: MODE.OFF,
   custom: {}
 }
-
 export const SESSION_EVENTS = {
   PAUSE: 'session-pause',
   RESET: 'session-reset',
@@ -42,16 +45,16 @@ export class SessionEntity {
     this.setup(opts)
   }
 
-  setup ({ agentIdentifier, key, value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS, storageAPI = new LocalMemory() }) {
-    if (!agentIdentifier || !key) throw new Error('Missing Required Fields')
-    if (!isBrowserScope) this.storage = new LocalMemory()
-    else this.storage = storageAPI
-
+  setup ({ agentIdentifier, key, storage, value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS }) {
+    if (!agentIdentifier || !key || !storage) {
+      throw new Error(`Missing required field(s):${!agentIdentifier ? ' agentID' : ''}${!key ? ' key' : ''}${!storage ? ' storage' : ''}`)
+    }
+    this.agentIdentifier = agentIdentifier
+    this.storage = storage
     this.state = {}
 
     this.sync(model)
 
-    this.agentIdentifier = agentIdentifier
     // key is intended to act as the k=v pair
     this.key = key
     // value is intended to act as the primary value of the k=v pair
@@ -183,7 +186,7 @@ export class SessionEntity {
       this.sync(data) // update the parent class "state" properties with the local storage values
       //
       // TODO - compression would need happen here if we decide to do it
-      this.storage.set(this.lookupKey, stringify(data))
+      this.storage.set(this.lookupKey, stringify(this.state))
       return data
     } catch (e) {
       // storage is inaccessible
@@ -207,7 +210,7 @@ export class SessionEntity {
       this.setup({
         agentIdentifier: this.agentIdentifier,
         key: this.key,
-        storageAPI: this.storage,
+        storage: this.storage,
         expiresMs: this.expiresMs,
         inactiveMs: this.inactiveMs
       })

package/src/common/timer/interaction-timer.js

@@ -44,8 +44,8 @@ export class InteractionTimer extends Timer {
         if (state === 'hidden') this.pause()
         // vis change --> visible is treated like a new interaction with the page
         else {
-          this.onResume()
           this.refresh()
+          this.onResume() // emit resume event after state updated
         }
       }, false, false, this.abortController?.signal)
     }

package/src/common/timer/timer.js

@@ -1,4 +1,3 @@
-
 export class Timer {
   constructor (opts, ms) {
     if (!opts.onEnd) throw new Error('onEnd handler is required')