@newrelic/browser-agent 0.1.231 → 1.232.1

package/dist/esm/common/session/session-entity.test.js

@@ -0,0 +1,434 @@
+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';
+jest.mock('../timer/timer');
+jest.mock('../timer/interaction-timer');
+jest.useFakeTimers();
+const mockBrowserScope = jest.fn().mockImplementation(() => true);
+jest.mock('../util/global-scope', () => ({
+  __esModule: true,
+  get isBrowserScope() {
+    return mockBrowserScope();
+  },
+  get globalScope() {
+    return global.window;
+  }
+}));
+beforeEach(() => {
+  jest.restoreAllMocks();
+  mockBrowserScope.mockReturnValue(true);
+});
+describe('constructor', () => {
+  test('must use required fields', () => {
+    try {
+      expect(new SessionEntity({})).toThrow(new Error('Missing Required Fields'));
+    } catch (err) {}
+  });
+  test('top-level properties are set and exposed', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+    expect(session).toMatchObject({
+      agentIdentifier: expect.any(String),
+      key: expect.any(String),
+      value: expect.any(String),
+      expiresMs: expect.any(Number),
+      expiresAt: expect.any(Number),
+      expiresTimer: expect.any(Object),
+      inactiveMs: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      inactiveTimer: expect.any(Object),
+      isNew: expect.any(Boolean),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean),
+      storage: expect.any(Object)
+    });
+  });
+  test('can use sane defaults', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }));
+  });
+  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
+    });
+    expect(session.expiresAt).toEqual(now + 100);
+  });
+  test('expiresAt is the correct future timestamp - existing session', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const existingData = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        value,
+        expiresAt: now + 5000,
+        inactiveAt: Infinity
+      }
+    });
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      expiresMs: 100,
+      storageAPI: existingData
+    });
+    expect(session.expiresAt).toEqual(now + 5000);
+  });
+  test('expiresAt never expires if 0', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      expiresMs: 0
+    });
+    expect(session.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
+    });
+    expect(session.inactiveAt).toEqual(now + 100);
+  });
+  test('inactiveAt is the correct future timestamp - existing session', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const existingData = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        value,
+        inactiveAt: now + 5000,
+        expiresAt: Infinity
+      }
+    });
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      inactiveMs: 100,
+      storageAPI: existingData
+    });
+    expect(session.inactiveAt).toEqual(now + 5000);
+  });
+  test('inactiveAt never expires if 0', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      inactiveMs: 0
+    });
+    expect(session.inactiveAt).toEqual(Infinity);
+  });
+  test('should handle isNew', () => {
+    const newSession = new SessionEntity({
+      agentIdentifier,
+      key,
+      expiresMs: 10
+    });
+    expect(newSession.isNew).toBeTruthy();
+    const storageAPI = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        value,
+        expiresAt: Infinity,
+        inactiveAt: Infinity
+      }
+    });
+    const existingSession = new SessionEntity({
+      agentIdentifier,
+      key,
+      expiresMs: 10,
+      storageAPI
+    });
+    expect(existingSession.isNew).toBeFalsy();
+  });
+  test('invalid stored values sets new defaults', () => {
+    // missing required fields
+    const storageAPI = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        invalid_fields: true
+      }
+    });
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      storageAPI
+    });
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }));
+  });
+  test('expired expiresAt value in storage sets new defaults', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const storageAPI = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        value,
+        expiresAt: now - 100,
+        inactiveAt: Infinity
+      }
+    });
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      storageAPI
+    });
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }));
+  });
+  test('expired inactiveAt value in storage sets new defaults', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const storageAPI = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        value,
+        inactiveAt: now - 100,
+        expiresAt: Infinity
+      }
+    });
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      storageAPI
+    });
+    expect(session).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }));
+  });
+});
+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 sessionVal = session.value;
+    expect(session.value).toBeTruthy();
+    session.reset();
+    expect(session.value).toBeTruthy();
+    expect(session.value).not.toEqual(sessionVal);
+  });
+  test('custom data should be wiped on reset', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      expiresMs: 10
+    });
+    session.syncCustomAttribute('test', 123);
+    expect(session.custom.test).toEqual(123);
+    expect(session.read().custom.test).toEqual(123);
+
+    // simulate a timer expiring
+    session.reset();
+    expect(session.custom?.test).toEqual(undefined);
+    expect(session.read()?.custom?.test).toEqual(undefined);
+  });
+});
+describe('read()', () => {
+  test('"new" sessions get data from read()', () => {
+    const newSession = new SessionEntity({
+      agentIdentifier,
+      key,
+      expiresMs: 10
+    });
+    expect(newSession.isNew).toBeTruthy();
+    expect(newSession.read()).toEqual(expect.objectContaining({
+      value: expect.any(String),
+      expiresAt: expect.any(Number),
+      inactiveAt: expect.any(Number),
+      sessionReplayActive: expect.any(Boolean),
+      sessionTraceActive: expect.any(Boolean)
+    }));
+  });
+  test('"pre-existing" sessions get data from read()', () => {
+    const storageAPI = new LocalMemory({
+      ["".concat(PREFIX, "_").concat(key)]: {
+        value,
+        expiresAt: Infinity,
+        inactiveAt: Infinity
+      }
+    });
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      storageAPI
+    });
+    expect(session.isNew).toBeFalsy();
+    expect(session.read()).toEqual(expect.objectContaining({
+      value,
+      expiresAt: Infinity,
+      inactiveAt: Infinity
+    }));
+  });
+});
+describe('write()', () => {
+  test('write() sets data to top-level wrapper', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+    expect(session.value).not.toEqual(value);
+    expect(session.expiresAt).not.toEqual(Infinity);
+    expect(session.inactiveAt).not.toEqual(Infinity);
+    session.write({
+      value,
+      expiresAt: Infinity,
+      inactiveAt: Infinity
+    });
+    expect(session.value).toEqual(value);
+    expect(session.expiresAt).toEqual(Infinity);
+    expect(session.inactiveAt).toEqual(Infinity);
+  });
+  test('write() sets data that read() can access', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+    session.write({
+      value,
+      expiresAt: now + 100,
+      inactiveAt: now + 100
+    });
+    const read = session.read();
+    expect(read.value).toEqual(value);
+    expect(read.expiresAt).toEqual(now + 100);
+    expect(read.inactiveAt).toEqual(now + 100);
+  });
+  test('write() does not run with invalid data', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+    let out = session.write();
+    expect(out).toEqual(undefined);
+    out = session.write('string');
+    expect(out).toEqual(undefined);
+    out = session.write(123);
+    expect(out).toEqual(undefined);
+    out = session.write(true);
+    expect(out).toEqual(undefined);
+    out = session.write(false);
+    expect(out).toEqual(undefined);
+  });
+});
+describe('refresh()', () => {
+  test('refresh sets inactiveAt to future time', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      inactiveMs: 100
+    });
+    expect(session.inactiveAt).toEqual(now + 100);
+    jest.setSystemTime(now + 1000);
+    session.refresh();
+    expect(session.inactiveAt).toEqual(now + 100 + 1000);
+  });
+  test('refresh resets the entity if expiresTimer is invalid', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      value
+    });
+    expect(session.value).toEqual(value);
+    session.write({
+      ...session.read(),
+      expiresAt: now - 1
+    });
+    session.refresh();
+    expect(session.value).not.toEqual(value);
+  });
+  test('refresh resets the entity if inactiveTimer is invalid', () => {
+    const now = Date.now();
+    jest.setSystemTime(now);
+    const session = new SessionEntity({
+      agentIdentifier,
+      key,
+      value
+    });
+    expect(session.value).toEqual(value);
+    session.write({
+      ...session.read(),
+      inactiveAt: now - 1
+    });
+    session.refresh();
+    expect(session.value).not.toEqual(value);
+  });
+});
+describe('syncCustomAttribute()', () => {
+  test('Custom data can be managed by session entity', () => {
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+
+    // if custom has never been set, and a "delete" action is triggered, do nothing
+    session.syncCustomAttribute('test', null);
+    expect(session?.custom?.test).toEqual(undefined);
+    session.syncCustomAttribute('test', 1);
+    expect(session?.custom?.test).toEqual(1);
+    session.syncCustomAttribute('test', 'string');
+    expect(session?.custom?.test).toEqual('string');
+    session.syncCustomAttribute('test', false);
+    expect(session?.custom?.test).toEqual(false);
+
+    // null specifically deletes the object completely
+    session.syncCustomAttribute('test', null);
+    expect(session?.custom?.test).toEqual(undefined);
+  });
+  test('Only runs in browser scope', () => {
+    mockBrowserScope.mockReturnValue(false);
+    const session = new SessionEntity({
+      agentIdentifier,
+      key
+    });
+    session.syncCustomAttribute('test', 1);
+    expect(session.read().custom?.test).toEqual(undefined);
+  });
+});

package/dist/esm/common/storage/first-party-cookies.js

@@ -0,0 +1,28 @@
+export class FirstPartyCookies {
+  constructor(domain) {
+    this.domain = domain;
+  }
+  get(name) {
+    try {
+      var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+      if (match) return match[2];
+    } catch (err) {
+      return '';
+    }
+  }
+  set(key, value) {
+    try {
+      const cookie = "".concat(key, "=").concat(value, "; Domain=").concat(domain, "; Path=/");
+      document.cookie = cookie;
+    } catch (err) {
+      return;
+    }
+  }
+  remove(key) {
+    try {
+      return document.cookie = "".concat(key, "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; Domain=").concat(domain, "; Path=/");
+    } catch (err) {
+      return;
+    }
+  }
+}

package/dist/esm/common/storage/local-memory.js

@@ -0,0 +1,28 @@
+export class LocalMemory {
+  constructor() {
+    let initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    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;
+    }
+  }
+}

package/dist/esm/common/storage/local-memory.test.js

@@ -0,0 +1,18 @@
+import { LocalMemory } from './local-memory';
+test('Local-memory', () => {
+  const LM = new LocalMemory({
+    test: 1
+  });
+  expect(LM.state).toEqual({
+    test: 1
+  });
+  expect(LM.get('test')).toEqual(1);
+  LM.set('test', 2);
+  expect(LM.get('test')).toEqual(2);
+  LM.set('test');
+  expect(LM.get('test')).toEqual(undefined);
+  LM.set('test', 2);
+  expect(LM.get('test')).toEqual(2);
+  LM.remove('test');
+  expect(LM.get('test')).toEqual(undefined);
+});

package/dist/esm/common/storage/local-storage.js

@@ -0,0 +1,26 @@
+export class LocalStorage {
+  get(key) {
+    try {
+      // localStorage strangely type-casts non-existing data to "null"...
+      // Cast it back to undefined if it doesnt exist
+      return localStorage.getItem(key) || undefined;
+    } catch (err) {
+      return '';
+    }
+  }
+  set(key, value) {
+    try {
+      if (value === undefined || value === null) return this.remove(key);
+      return localStorage.setItem(key, value);
+    } catch (err) {
+      return;
+    }
+  }
+  remove(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch (err) {
+      return;
+    }
+  }
+}

package/dist/esm/common/storage/local-storage.test.js

@@ -0,0 +1,12 @@
+import { LocalStorage } from './local-storage';
+test('Local-memory', () => {
+  const LS = new LocalStorage();
+  LS.set('test', 1);
+  expect(LS.get('test')).toEqual('1');
+  LS.set('test');
+  expect(LS.get('test')).toEqual(undefined);
+  LS.set('test', 2);
+  expect(LS.get('test')).toEqual('2');
+  LS.remove('test');
+  expect(LS.get('test')).toEqual(undefined);
+});

package/dist/esm/common/timer/interaction-timer.js

@@ -0,0 +1,71 @@
+import { Timer } from './timer';
+import { subscribeToVisibilityChange } from '../window/page-visibility';
+import { debounce } from '../util/invoke';
+import { isBrowserScope } from '../util/global-scope';
+export class InteractionTimer extends Timer {
+  constructor(opts, ms) {
+    super(opts, ms);
+    this.onRefresh = opts.onRefresh;
+    this.onPause = opts.onPause;
+
+    // used by pause/resume
+    this.remainingMs = undefined;
+    if (!opts.refreshEvents) opts.refreshEvents = ['click', 'keydown', 'scroll'];
+
+    // the abort controller is used to "reset" the event listeners and prevent them from duplicating when new sessions are created
+    try {
+      this.abortController = new AbortController();
+    } catch (e) {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
+    }
+    if (isBrowserScope && opts.ee) {
+      if (opts.ee) {
+        const debouncedRefresh = debounce(this.refresh.bind(this), 500, {
+          leading: true
+        });
+        opts.ee.on('fn-end', evts => {
+          if (opts.refreshEvents.includes(evts?.[0]?.type)) {
+            debouncedRefresh();
+          }
+        });
+      }
+
+      // watch for the vis state changing.  If the page is hidden, the local inactivity timer should be paused
+      // if the page is brought BACK to visibility and the timer hasnt "naturally" expired, refresh the timer...
+      // this is to support the concept that other tabs could be experiencing activity.  The thought would be that
+      // "backgrounded" tabs would pause, while "closed" tabs that "reopen" will just instantiate a new SessionEntity class if restored
+      // which will do a "hard" check of the timestamps.
+
+      // NOTE -- this does not account for 2 browser windows open side by side, blurring/focusing between them
+      // IF DEEMED necessary, more event handling would be needed to account for this.
+      subscribeToVisibilityChange(state => {
+        if (state === 'hidden') this.pause();
+        // vis change --> visible is treated like a new interaction with the page
+        else this.refresh();
+      }, false, false, this.abortController?.signal);
+    }
+  }
+  abort() {
+    this.clear();
+    this.abortController?.abort();
+  }
+  pause() {
+    this.onPause?.();
+    clearTimeout(this.timer);
+    this.remainingMs = this.initialMs - (Date.now() - this.startTimestamp);
+  }
+  refresh(cb, ms) {
+    this.clear();
+    this.timer = this.create(cb, ms);
+    this.startTimestamp = Date.now();
+    this.remainingMs = undefined;
+    this.onRefresh?.();
+  }
+
+  // NOT CURRENTLY UTILIZED BY ANYTHING
+  // resume () {
+  //   if (!this.remainingMs || !this.isValid()) return
+  //   this.timer = this.create(this.cb, this.remainingMs)
+  //   this.remainingMs = undefined
+  // }
+}