@newrelic/browser-agent 1.238.0 → 1.239.0

package/src/common/config/state/info.test.js

@@ -0,0 +1,31 @@
+let isValid, getInfo, setInfo
+beforeEach(async () => {
+  jest.resetModules()
+  ;({ isValid, getInfo, setInfo } = await import('./info.js'))
+})
+
+test('set/getInfo should throw on an invalid agent id', () => {
+  // currently only checks if it's a truthy value
+  expect(() => setInfo(undefined, {})).toThrow('require an agent id')
+  expect(() => getInfo(undefined)).toThrow('require an agent id')
+  expect(() => setInfo('', {})).toThrow('require an agent id')
+  expect(() => getInfo('')).toThrow('require an agent id')
+})
+
+test('set/getInfo works correctly', () => {
+  expect(() => setInfo(123, { beacon: 'im here' })).not.toThrow() // notice setInfo accepts numbers
+  let cachedObj = getInfo('123')
+  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
+  expect(cachedObj.beacon).toEqual('im here')
+  expect(cachedObj.licenseKey).toEqual(undefined) // this should mirror default in info.js
+})
+
+test('isValid is correct', () => {
+  setInfo('ab', { errorBeacon: 'some value' })
+  setInfo('cd', { errorBeacon: 'some value', licenseKey: 'cereal box' })
+  expect(isValid('ab')).toBeFalsy()
+  expect(isValid('cd')).toBeFalsy()
+
+  setInfo('ef', { errorBeacon: 'some value', licenseKey: 'cereal box', applicationID: '25' })
+  expect(isValid('ef')).toBeTruthy()
+})

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

@@ -8,9 +8,8 @@ const model = () => {
     maskInputOptions: { password: true }
   }
   return {
-    allow_bfcache: true, // *cli - temporary feature flag for BFCache work
     privacy: { cookies_enabled: true }, // *cli - per discussion, default should be true
-    ajax: { deny_list: undefined, block_internal: true, enabled: true, harvestTimeSeconds: 10 },
+    ajax: { deny_list: undefined, block_internal: true, enabled: true, harvestTimeSeconds: 10, autoStart: true },
     distributed_tracing: {
       enabled: undefined,
       exclude_newrelic_header: undefined,
@@ -25,15 +24,16 @@ const model = () => {
     },
     ssl: undefined,
     obfuscate: undefined,
-    jserrors: { enabled: true, harvestTimeSeconds: 10 },
-    metrics: { enabled: true },
-    page_action: { enabled: true, harvestTimeSeconds: 30 },
-    page_view_event: { enabled: true },
-    page_view_timing: { enabled: true, harvestTimeSeconds: 30, long_task: false },
-    session_trace: { enabled: true, harvestTimeSeconds: 10 },
+    jserrors: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
+    metrics: { enabled: true, autoStart: true },
+    page_action: { enabled: true, harvestTimeSeconds: 30, autoStart: true },
+    page_view_event: { enabled: true, autoStart: true },
+    page_view_timing: { enabled: true, harvestTimeSeconds: 30, long_task: false, autoStart: true },
+    session_trace: { enabled: true, harvestTimeSeconds: 10, autoStart: true },
     harvest: { tooManyRequestsDelay: 60 },
     session_replay: {
       // feature settings
+      autoStart: true,
       enabled: false,
       harvestTimeSeconds: 60,
       sampleRate: 0.1,
@@ -61,26 +61,27 @@ const model = () => {
         hiddenState.maskInputOptions = { ...val, password: true }
       }
     },
-    spa: { enabled: true, harvestTimeSeconds: 10 }
+    spa: { enabled: true, harvestTimeSeconds: 10, autoStart: true }
   }
 }
 
 const _cache = {}
+const missingAgentIdError = 'All configuration objects require an agent identifier!'
 
 export function getConfiguration (id) {
-  if (!id) throw new Error('All configuration objects require an agent identifier!')
+  if (!id) throw new Error(missingAgentIdError)
   if (!_cache[id]) throw new Error(`Configuration for ${id} was never set`)
   return _cache[id]
 }
 
 export function setConfiguration (id, obj) {
-  if (!id) throw new Error('All configuration objects require an agent identifier!')
+  if (!id) throw new Error(missingAgentIdError)
   _cache[id] = getModeledObject(obj, model())
   gosNREUMInitializedAgents(id, _cache[id], 'config')
 }
 
 export function getConfigurationValue (id, path) {
-  if (!id) throw new Error('All configuration objects require an agent identifier!')
+  if (!id) throw new Error(missingAgentIdError)
   var val = getConfiguration(id)
   if (val) {
     var parts = path.split('.')

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

@@ -0,0 +1,28 @@
+let getConfiguration, setConfiguration, getConfigurationValue
+beforeEach(async () => {
+  jest.resetModules()
+  ;({ getConfiguration, setConfiguration, getConfigurationValue } = await import('./init.js'))
+})
+
+test('set/getConfiguration should throw on an invalid agent id', () => {
+  // currently only checks if it's a truthy value
+  expect(() => setConfiguration(undefined, {})).toThrow('require an agent id')
+  expect(() => getConfiguration(undefined)).toThrow('require an agent id')
+  expect(() => setConfiguration('', {})).toThrow('require an agent id')
+  expect(() => getConfiguration('')).toThrow('require an agent id')
+})
+
+test('set/getConfiguration works correctly', () => {
+  expect(() => setConfiguration(123, { jserrors: { enabled: false } })).not.toThrow() // notice setConfiguration accepts numbers
+  let cachedObj = getConfiguration('123')
+  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
+  expect(cachedObj.jserrors.enabled).toEqual(false)
+  expect(cachedObj.page_action.enabled).toEqual(true) // this should mirror default in init.js
+})
+
+test('getConfigurationValue parses path correctly', () => {
+  setConfiguration('ab', { page_action: { harvestTimeSeconds: 1000 } })
+  expect(getConfigurationValue('ab', '')).toBeUndefined()
+  expect(getConfigurationValue('ab', 'page_action')).toEqual({ enabled: true, harvestTimeSeconds: 1000, autoStart: true })
+  expect(getConfigurationValue('ab', 'page_action.harvestTimeSeconds')).toEqual(1000)
+})

package/src/common/config/state/loader-config.test.js

@@ -0,0 +1,21 @@
+let getLoaderConfig, setLoaderConfig
+beforeEach(async () => {
+  jest.resetModules()
+  ;({ getLoaderConfig, setLoaderConfig } = await import('./loader-config.js'))
+})
+
+test('set/getLoaderConfig should throw on an invalid agent id', () => {
+  // currently only checks if it's a truthy value
+  expect(() => setLoaderConfig(undefined, {})).toThrow('require an agent id')
+  expect(() => getLoaderConfig(undefined)).toThrow('require an agent id')
+  expect(() => setLoaderConfig('', {})).toThrow('require an agent id')
+  expect(() => getLoaderConfig('')).toThrow('require an agent id')
+})
+
+test('set/getLoaderConfig works correctly', () => {
+  expect(() => setLoaderConfig(123, { trustKey: 1 })).not.toThrow() // notice setLoaderConfig accepts numbers
+  let cachedObj = getLoaderConfig('123')
+  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
+  expect(cachedObj.trustKey).toEqual(1)
+  expect(cachedObj.xpid).toBeUndefined() // this should mirror default in loader-config.js
+})

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

@@ -5,8 +5,6 @@ import { BUILD_ENV, DIST_METHOD, VERSION } from '../../constants/env'
 
 const model = {
   buildEnv: BUILD_ENV,
-  bytesSent: {}, // Used for SM to capture body bytes sent per endpoint
-  queryBytesSent: {}, // Used for SM to capture query parameter bytes sent per endpoint
   customTransaction: undefined,
   disabled: false,
   distMethod: DIST_METHOD,

package/src/common/config/state/runtime.test.js

@@ -0,0 +1,21 @@
+let getRuntime, setRuntime
+beforeEach(async () => {
+  jest.resetModules()
+  ;({ getRuntime, setRuntime } = await import('./runtime.js'))
+})
+
+test('set/getRuntime should throw on an invalid agent id', () => {
+  // currently only checks if it's a truthy value
+  expect(() => setRuntime(undefined, {})).toThrow('require an agent id')
+  expect(() => getRuntime(undefined)).toThrow('require an agent id')
+  expect(() => setRuntime('', {})).toThrow('require an agent id')
+  expect(() => getRuntime('')).toThrow('require an agent id')
+})
+
+test('set/getRuntime works correctly', () => {
+  expect(() => setRuntime(123, { session: 1 })).not.toThrow() // notice setRuntime accepts numbers
+  let cachedObj = getRuntime('123')
+  expect(Object.keys(cachedObj).length).toBeGreaterThan(1)
+  expect(cachedObj.session).toEqual(1)
+  expect(cachedObj.maxBytes).toEqual(30000) // this should mirror default in runtime.js
+})

package/src/common/constants/__mocks__/runtime.js

@@ -3,6 +3,6 @@ export const isWorkerScope = false
 export const globalScope = window
 export const initialLocation = '' + globalScope?.location
 export const isiOS = false
-export const iOS_below16 = false
+export const iOSBelow16 = false
 export const ffVersion = 0
 export const supportsSendBeacon = true

package/src/common/constants/runtime.js

@@ -55,7 +55,7 @@ export const isiOS = /iPad|iPhone|iPod/.test(navigator.userAgent)
  * did not work. This affects our onFCP metric in particular since web-vitals uses that flag to retrieve paint timing entries.
  * This was fixed in v16+.
  */
-export const iOS_below16 = (isiOS && typeof SharedWorker === 'undefined')
+export const iOSBelow16 = (isiOS && typeof SharedWorker === 'undefined')
 
 export const ffVersion = (() => {
   const match = navigator.userAgent.match(/Firefox[/\s](\d+\.\d+)/)

package/src/common/constants/runtime.test.js

@@ -122,7 +122,7 @@ test.each([
   { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Safari/605.1.15', expected: false },
   { userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0', expected: false },
   { userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 13.4; rv:109.0) Gecko/20100101 Firefox/114.0', expected: false }
-])('should set iOS_below16 to $expected for $userAgent', async ({ userAgent, expected }) => {
+])('should set iOSBelow16 to $expected for $userAgent', async ({ userAgent, expected }) => {
   if (!expected) {
     global.SharedWorker = class SharedWorker {}
   }
@@ -132,7 +132,7 @@ test.each([
 
   delete global.SharedWorker
 
-  expect(runtime.iOS_below16).toEqual(expected)
+  expect(runtime.iOSBelow16).toEqual(expected)
 })
 
 test.each([

package/src/common/constants/shared-channel.js

@@ -5,7 +5,7 @@
  */
 
 let onReplayReady
-const sessionReplayInitialized = new Promise(resolve => onReplayReady = resolve)
+const sessionReplayInitialized = new Promise(resolve => { onReplayReady = resolve })
 
 export const sharedChannel = Object.freeze({
   onReplayReady,

package/src/common/deny-list/deny-list.js

@@ -81,11 +81,7 @@ function domainMatchesPattern (pattern, domain) {
     return false
   }
 
-  if (domain.indexOf(pattern) === (domain.length - pattern.length)) {
-    return true
-  }
-
-  return false
+  return domain.indexOf(pattern) === (domain.length - pattern.length)
 }
 
 /**
@@ -108,9 +104,5 @@ function comparePath (pattern, path) {
     return true
   }
 
-  if (pattern === path) {
-    return true
-  }
-
-  return false
+  return pattern === path
 }

package/src/common/drain/drain.js

@@ -44,7 +44,6 @@ function curateRegistry (agentIdentifier) {
  */
 export function drain (agentIdentifier = '', featureName = 'feature') {
   curateRegistry(agentIdentifier)
-
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
   // This could happen in tests, or loaders that directly import the aggregator. In these cases it is safe to
   // drain the feature group immediately rather than waiting to drain all at once.
@@ -59,6 +58,7 @@ export function drain (agentIdentifier = '', featureName = 'feature') {
   if (items.every(([key, values]) => values.staged)) {
     items.sort((a, b) => a[1].priority - b[1].priority)
     items.forEach(([group]) => {
+      registry[agentIdentifier].delete(group)
       drainGroup(group)
     })
   }

package/src/common/drain/drain.test.js

@@ -0,0 +1,74 @@
+let registerDrain, drain, ee
+beforeEach(async () => {
+  jest.resetModules()
+  ;({ registerDrain, drain } = await import('./drain'))
+  ;({ ee } = await import('../event-emitter/contextual-ee'))
+})
+
+test('can register a feat and drain it', () => {
+  registerDrain('abcd', 'page_view_event')
+
+  let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+  drain('abcd', 'page_view_event')
+  expect(emitSpy).toHaveBeenCalledWith('drain-page_view_event', expect.anything())
+})
+
+test('other unregistered drains do not affect feat reg & drain', () => {
+  registerDrain('abcd', 'page_view_event')
+
+  let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+  drain('abcd', 'timon')
+  expect(emitSpy).toHaveBeenCalledWith('drain-timon', expect.anything())
+  expect(emitSpy).not.toHaveBeenCalledWith('drain-page_view_event', expect.anything())
+
+  drain('abcd', 'page_view_event')
+  expect(emitSpy).toHaveBeenCalledWith('drain-page_view_event', expect.anything())
+})
+
+describe('drain', () => {
+  test('does not execute until all registered groups calls it and in order', () => {
+    registerDrain('abcd', 'page_view_timing')
+    registerDrain('abcd', 'page_view_event')
+
+    let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+    drain('abcd', 'page_view_event')
+    expect(emitSpy).not.toHaveBeenCalled()
+
+    drain('abcd', 'page_view_timing')
+    // The priority order of features is also checked here, even though the latter was registered first.
+    expect(emitSpy).toHaveBeenNthCalledWith(1, 'drain-page_view_event', expect.anything())
+    expect(emitSpy).toHaveBeenNthCalledWith(2, 'drain-page_view_timing', expect.anything())
+  })
+
+  test('does not require registration for non-feat groups', () => {
+    let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+    drain('abcd', 'pumbaa')
+    expect(emitSpy).toHaveBeenCalledWith('drain-pumbaa', expect.anything())
+  })
+
+  test('defaults to "feature" group when not provided one', () => {
+    let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+    drain('abcd')
+    expect(emitSpy).toHaveBeenCalledWith('drain-feature', expect.anything())
+  })
+
+  test('works on the global ee when agent id not provided', () => {
+    let emitSpy = jest.spyOn(ee, 'emit')
+    drain()
+    expect(emitSpy).toHaveBeenCalledWith('drain-feature', expect.anything())
+  })
+})
+
+test('non-feat groups can register and drain too alongside features', () => {
+  registerDrain('abcd', 'page_view_event')
+  registerDrain('abcd', 'simba')
+
+  console.log(JSON.stringify(ee.get('abcd')))
+  let emitSpy = jest.spyOn(ee.get('abcd'), 'emit')
+  drain('abcd', 'simba')
+  expect(emitSpy).not.toHaveBeenCalled()
+
+  drain('abcd', 'page_view_event')
+  expect(emitSpy).toHaveBeenNthCalledWith(1, 'drain-simba', expect.anything()) // non-feat have prio of 0
+  expect(emitSpy).toHaveBeenNthCalledWith(2, 'drain-page_view_event', expect.anything())
+})

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

@@ -41,16 +41,16 @@ function ee (old, debugId) {
 
   var emitter = {
     on: addEventListener,
-    addEventListener: addEventListener,
-    removeEventListener: removeEventListener,
-    emit: emit,
+    addEventListener,
+    removeEventListener,
+    emit,
     get: getOrCreate,
-    listeners: listeners,
-    context: context,
+    listeners,
+    context,
     buffer: bufferEventsByGroup,
     abort,
     aborted: false,
-    isBuffering: isBuffering,
+    isBuffering,
     debugId,
     backlog: isolatedBacklog ? {} : old && typeof old.backlog === 'object' ? old.backlog : {}
 

package/src/common/harvest/harvest-scheduler.js

@@ -7,7 +7,6 @@ import * as submitData from '../util/submit-data'
 import { SharedContext } from '../context/shared-context'
 import { Harvest } from './harvest'
 import { subscribeToEOL } from '../unload/eol'
-import { getConfigurationValue } from '../config/config'
 import { SESSION_EVENTS } from '../session/session-entity'
 
 /**
@@ -36,7 +35,7 @@ export class HarvestScheduler extends SharedContext {
     this.harvest = new Harvest(this.sharedContext)
 
     // unload if EOL mechanism fires
-    subscribeToEOL(this.unload.bind(this), getConfigurationValue(this.sharedContext.agentIdentifier, 'allow_bfcache')) // TO DO: remove feature flag after rls stable
+    subscribeToEOL(this.unload.bind(this))
 
     /* Flush all buffered data if session resets and give up retries. This should be synchronous to ensure that the correct `session` value is sent.
       Since session-reset generates a new session ID and the ID is grabbed at send-time, any delays or retries would cause the payload to be sent under
@@ -103,7 +102,7 @@ export class HarvestScheduler extends SharedContext {
       if (!submitMethod) return false
 
       const retry = !opts?.unload && submitMethod === submitData.xhr
-      payload = this.opts.getPayload({ retry: retry })
+      payload = this.opts.getPayload({ retry })
 
       if (!payload) {
         if (this.started) {
@@ -143,8 +142,6 @@ export class HarvestScheduler extends SharedContext {
     if (this.started) {
       this.scheduleHarvest()
     }
-
-    return
   }
 
   onHarvestFinished (opts, result) {

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

@@ -2,7 +2,6 @@ import { faker } from '@faker-js/faker'
 
 import * as submitData from '../util/submit-data'
 import { subscribeToEOL } from '../unload/eol'
-import { getConfigurationValue } from '../config/config'
 import { Harvest } from './harvest'
 
 import { HarvestScheduler } from './harvest-scheduler'
@@ -31,13 +30,10 @@ describe('unload', () => {
     jest.spyOn(harvestSchedulerInstance, 'runHarvest').mockImplementation(jest.fn())
   })
 
-  test('should subscribe to eol with allow_bfcache setting', () => {
-    const mockedBFCacheSetting = faker.datatype.uuid()
-    jest.mocked(getConfigurationValue).mockReturnValue(mockedBFCacheSetting)
-
+  test('should subscribe to eol', () => {
     new HarvestScheduler()
 
-    expect(subscribeToEOL).toHaveBeenCalledWith(expect.any(Function), mockedBFCacheSetting)
+    expect(subscribeToEOL).toHaveBeenCalledWith(expect.any(Function))
   })
 
   test('should run onUnload callback', () => {

package/src/common/harvest/harvest.js

@@ -96,7 +96,8 @@ export class Harvest extends SharedContext {
       return false
     }
 
-    let url = `${this.getScheme()}://${info.errorBeacon}${endpoint !== 'rum' ? `/${endpoint}` : ''}/1/${info.licenseKey}`
+    const endpointURLPart = endpoint !== 'rum' ? `/${endpoint}` : ''
+    let url = `${this.getScheme()}://${info.errorBeacon}${endpointURLPart}/1/${info.licenseKey}`
     if (customUrl) url = customUrl
     if (raw) url = `${this.getScheme()}://${info.errorBeacon}/${endpoint}`
 
@@ -127,11 +128,6 @@ export class Harvest extends SharedContext {
       body = ''
     }
 
-    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0
-    // Get query bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
-    agentRuntime.queryBytesSent[endpoint] = (agentRuntime.queryBytesSent[endpoint] || 0) + fullUrl.split('?').slice(-1)[0]?.length || 0
-
     const headers = []
 
     headers.push({ key: 'content-type', value: 'text/plain' })

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

@@ -157,8 +157,6 @@ describe('_send', () => {
       licenseKey
     })
     jest.mocked(configModule.getRuntime).mockReturnValue({
-      bytesSent: {},
-      queryBytesSent: {},
       maxBytes: Infinity
     })
 

package/src/common/ids/id.test.js

@@ -67,25 +67,25 @@ test('id is zero on global scope', async () => {
 })
 
 test('id on prototype is correctly inherited', () => {
-  const fn = jest.fn()
+  const Ctor = jest.fn()
   const a = {}
 
   idFn(a)
-  fn.prototype = a
+  Ctor.prototype = a
 
-  const b = new fn()
+  const b = new Ctor()
 
   expect(b['nr@id']).toEqual(a['nr@id'])
 })
 
 test('id on prototype is different from instance', () => {
-  const fn = jest.fn()
+  const Ctor = jest.fn()
   const a = {}
 
   idFn(a)
-  fn.prototype = a
+  Ctor.prototype = a
 
-  const b = new fn()
+  const b = new Ctor()
   const result = idFn(b)
 
   expect(b['nr@id']).toEqual(result)

package/src/common/serialize/bel-serializer.js

@@ -32,7 +32,7 @@ export function getAddStringContext (agentIdentifier) {
 
   function addString (str) {
     if (typeof str === 'undefined' || str === '') return ''
-    var obfuscator = new Obfuscator({ agentIdentifier: agentIdentifier })
+    var obfuscator = new Obfuscator({ agentIdentifier })
     str = String(str)
     if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str)
     if (hasOwnProp.call(stringTable, str)) {

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

@@ -13,6 +13,7 @@ class LocalMemory {
     try {
       return this.state[key]
     } catch (err) {
+      // Error is ignored
       return ''
     }
   }
@@ -22,7 +23,7 @@ class LocalMemory {
       if (value === undefined || value === null) return this.remove(key)
       this.state[key] = value
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 
@@ -30,7 +31,7 @@ class LocalMemory {
     try {
       delete this.state[key]
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 }

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

@@ -42,10 +42,8 @@ export class SessionEntity {
    * expiresMs and inactiveMs are used to "expire" the session, but can be overridden in the constructor. Pass 0 to disable expiration timers.
    */
   constructor (opts) {
-    this.setup(opts)
-  }
+    const { agentIdentifier, key, storage } = opts
 
-  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' : ''}`)
     }
@@ -53,20 +51,24 @@ export class SessionEntity {
     this.storage = storage
     this.state = {}
 
-    this.sync(model)
-
     // key is intended to act as the k=v pair
     this.key = key
+
+    this.ee = ee.get(agentIdentifier)
+    wrapEvents(this.ee)
+    this.setup(opts)
+  }
+
+  setup ({ value = generateRandomHexString(16), expiresMs = DEFAULT_EXPIRES_MS, inactiveMs = DEFAULT_INACTIVE_MS }) {
+    this.state = {}
+    this.sync(model)
+
     // value is intended to act as the primary value of the k=v pair
     this.state.value = value
 
     this.expiresMs = expiresMs
     this.inactiveMs = inactiveMs
 
-    this.ee = ee.get(agentIdentifier)
-
-    wrapEvents(this.ee)
-
     // the first time the session entity class is instantiated, we check the storage API for an existing
     // object. If it exists, the values inside the object are used to inform the timers that run locally.
     // if the initial read is empty, it allows us to set a "fresh" "new" session immediately.

package/src/common/storage/first-party-cookies.js

@@ -8,24 +8,25 @@ export class FirstPartyCookies {
       var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'))
       if (match) return match[2]
     } catch (err) {
+      // Error is ignored
       return ''
     }
   }
 
   set (key, value) {
     try {
-      const cookie = `${key}=${value}; Domain=${domain}; Path=/`
+      const cookie = `${key}=${value}; Domain=${this.domain}; Path=/`
       document.cookie = cookie
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 
   remove (key) {
     try {
-      return document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=${domain}; Path=/`
+      document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=${this.domain}; Path=/`
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 }

package/src/common/storage/local-storage.js

@@ -5,6 +5,7 @@ export class LocalStorage {
       // Cast it back to undefined if it doesnt exist
       return localStorage.getItem(key) || undefined
     } catch (err) {
+      // Error is ignored
       return ''
     }
   }
@@ -14,7 +15,7 @@ export class LocalStorage {
       if (value === undefined || value === null) return this.remove(key)
       return localStorage.setItem(key, value)
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 
@@ -22,7 +23,7 @@ export class LocalStorage {
     try {
       localStorage.removeItem(key)
     } catch (err) {
-      return
+      // Error is ignored
     }
   }
 }