utneque 1.0.0

package/packages/browser/src/core/stats/__tests__/remote-metrics.test.ts

@@ -0,0 +1,189 @@
+import unfetch from 'unfetch'
+import { RemoteMetrics } from '../remote-metrics'
+import { version } from '../../../generated/version'
+
+jest.mock('unfetch', () => {
+  return jest.fn()
+})
+
+describe('remote metrics', () => {
+  test('stores metrics in a queue when sampling', () => {
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+    })
+    remote.increment('analytics_js.banana', ['phone:1'])
+
+    expect(remote.queue.length).toBe(1)
+    const metric = remote.queue[0]
+    expect(metric.tags).toEqual({
+      library: 'analytics.js',
+      library_version: `npm:next-${version}`,
+      phone: '1',
+    })
+
+    expect(metric.metric).toBe('analytics_js.banana')
+    expect(metric.type).toBe('Counter')
+    expect(metric.value).toBe(1)
+  })
+
+  test('does not store when not sampling', () => {
+    const remote = new RemoteMetrics({
+      sampleRate: 0,
+    })
+    remote.increment('analytics_js.banana', ['phone:1'])
+
+    expect(remote.queue).toMatchInlineSnapshot(`Array []`)
+  })
+
+  test('ignores messages after reaching threshold', () => {
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+      maxQueueSize: 3,
+    })
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    remote.increment('analytics_js.banana', ['phone:1'])
+    remote.increment('analytics_js.banana', ['phone:1'])
+    remote.increment('analytics_js.banana', ['phone:1'])
+
+    expect(remote.queue.length).toBe(3)
+  })
+
+  test('force flushes errors', () => {
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+    })
+
+    const spy = jest.spyOn(remote, 'flush')
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    expect(spy).not.toHaveBeenCalled()
+
+    remote.increment('analytics_js.banana.error', ['phone:1'])
+    expect(spy).toHaveBeenCalled()
+  })
+
+  test('sends metrics requests on flush', async () => {
+    const spy = jest.mocked(unfetch).mockImplementation()
+
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+    })
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    await remote.flush()
+
+    expect(spy).toHaveBeenCalled()
+    const [url, request] = spy.mock.calls[0]
+
+    expect(url).toBe('https://us-east-1.hightouch-events.com/v1/m')
+    expect(request).toMatchInlineSnapshot(
+      { body: expect.anything() },
+      `
+      Object {
+        "body": Anything,
+        "headers": Object {
+          "Accept": "application/json",
+          "Content-Type": "application/json",
+        },
+        "method": "POST",
+      }
+    `
+    )
+    const body = JSON.parse(request?.body as any)
+    expect(body).toMatchInlineSnapshot(
+      {
+        series: [
+          {
+            tags: {
+              library_version: expect.any(String),
+            },
+          },
+        ],
+      },
+      `
+      Object {
+        "series": Array [
+          Object {
+            "metric": "analytics_js.banana",
+            "tags": Object {
+              "library": "analytics.js",
+              "library_version": Any<String>,
+              "phone": "1",
+            },
+            "type": "Counter",
+            "value": 1,
+          },
+        ],
+      }
+    `
+    )
+  })
+
+  test('clears queue after sending', async () => {
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+    })
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    expect(remote.queue.length).toBe(1)
+
+    await remote.flush()
+    expect(remote.queue.length).toBe(0)
+  })
+
+  test('does not crash on errors', async () => {
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation()
+
+    const error = new Error('aaay')
+    jest.mocked(unfetch).mockImplementation(() => {
+      throw error
+    })
+
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+    })
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    await remote.flush()
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      'Error sending hightouch performance metrics',
+      error
+    )
+  })
+
+  test('disables metrics reporting in case of errors', async () => {
+    jest.spyOn(console, 'error').mockImplementation()
+
+    const error = new Error('aaay')
+    jest.mocked(unfetch).mockImplementation(() => {
+      throw error
+    })
+
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+    })
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    await remote.flush()
+
+    expect(remote.sampleRate).toBe(0)
+  })
+
+  test('flushs on a schedule', () => {
+    jest.useFakeTimers()
+
+    const remote = new RemoteMetrics({
+      sampleRate: 100,
+      flushTimer: 100,
+    })
+
+    const flushSpy = jest.spyOn(remote, 'flush')
+
+    remote.increment('analytics_js.banana', ['phone:1'])
+    jest.advanceTimersByTime(500)
+
+    expect(flushSpy).toHaveBeenCalledTimes(5)
+  })
+})

package/packages/browser/src/core/stats/index.ts

@@ -0,0 +1,15 @@
+import { CoreStats } from '@ht-sdks/events-sdk-js-core'
+import { MetricsOptions, RemoteMetrics } from './remote-metrics'
+
+let remoteMetrics: RemoteMetrics | undefined
+
+export class Stats extends CoreStats {
+  static initRemoteMetrics(options?: MetricsOptions) {
+    remoteMetrics = new RemoteMetrics(options)
+  }
+
+  override increment(metric: string, by?: number, tags?: string[]): void {
+    super.increment(metric, by, tags)
+    remoteMetrics?.increment(metric, tags ?? [])
+  }
+}

package/packages/browser/src/core/stats/remote-metrics.ts

@@ -0,0 +1,144 @@
+import { fetch } from '../../lib/fetch'
+import { version } from '../../generated/version'
+import { getVersionType } from '../../lib/version-type'
+import { HIGHTOUCH_API_HOST } from '../constants'
+
+export interface MetricsOptions {
+  host?: string
+  sampleRate?: number
+  flushTimer?: number
+  maxQueueSize?: number
+}
+
+/**
+ * Type expected by the hightouch metrics API endpoint
+ */
+type RemoteMetric = {
+  type: 'Counter'
+  metric: string
+  value: 1
+  tags: {
+    library: string
+    library_version: string
+    [key: string]: string
+  }
+}
+
+const createRemoteMetric = (
+  metric: string,
+  tags: string[],
+  versionType: 'web' | 'npm'
+): RemoteMetric => {
+  const formattedTags = tags.reduce((acc, t) => {
+    const [k, v] = t.split(':')
+    acc[k] = v
+    return acc
+  }, {} as Record<string, string>)
+
+  return {
+    type: 'Counter',
+    metric,
+    value: 1,
+    tags: {
+      ...formattedTags,
+      library: 'analytics.js',
+      library_version:
+        versionType === 'web' ? `next-${version}` : `npm:next-${version}`,
+    },
+  }
+}
+
+function logError(err: unknown): void {
+  console.error('Error sending hightouch performance metrics', err)
+}
+
+export class RemoteMetrics {
+  private host: string
+  private flushTimer: number
+  private maxQueueSize: number
+
+  sampleRate: number
+  queue: RemoteMetric[]
+
+  constructor(options?: MetricsOptions) {
+    this.host = options?.host ?? HIGHTOUCH_API_HOST
+    this.sampleRate = options?.sampleRate ?? 1
+    this.flushTimer = options?.flushTimer ?? 30 * 1000 /* 30s */
+    this.maxQueueSize = options?.maxQueueSize ?? 20
+
+    this.queue = []
+
+    if (this.sampleRate > 0) {
+      let flushing = false
+
+      const run = (): void => {
+        if (flushing) {
+          return
+        }
+
+        flushing = true
+        this.flush().catch(logError)
+
+        flushing = false
+
+        setTimeout(run, this.flushTimer)
+      }
+      run()
+    }
+  }
+
+  increment(metric: string, tags: string[]): void {
+    // All metrics are part of an allow list in Tracking API
+    if (!metric.includes('analytics_js.')) {
+      return
+    }
+
+    // /m doesn't like empty tags
+    if (tags.length === 0) {
+      return
+    }
+
+    if (Math.random() > this.sampleRate) {
+      return
+    }
+
+    if (this.queue.length >= this.maxQueueSize) {
+      return
+    }
+
+    const remoteMetric = createRemoteMetric(metric, tags, getVersionType())
+    this.queue.push(remoteMetric)
+
+    if (metric.includes('error')) {
+      this.flush().catch(logError)
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (this.queue.length <= 0) {
+      return
+    }
+
+    await this.send().catch((error) => {
+      logError(error)
+      this.sampleRate = 0
+    })
+  }
+
+  private async send(): Promise<Response> {
+    const payload = { series: this.queue }
+    this.queue = []
+
+    const headers = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    }
+    const url = `https://${this.host}/v1/m`
+
+    return fetch(url, {
+      headers,
+      body: JSON.stringify(payload),
+      method: 'POST',
+    })
+  }
+}

package/packages/browser/src/core/storage/__tests__/cookieStorage.test.ts

@@ -0,0 +1,58 @@
+import { CookieStorage } from '../cookieStorage'
+import jar from 'js-cookie'
+
+describe('cookieStorage', () => {
+  function clearCookies() {
+    document.cookie.split(';').forEach(function (c) {
+      document.cookie = c
+        .replace(/^ +/, '')
+        .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/')
+    })
+  }
+
+  afterEach(() => {
+    clearCookies()
+  })
+
+  describe('cookie options', () => {
+    it('should have default cookie options', () => {
+      const cookie = new CookieStorage()
+      expect(cookie['options'].domain).toBe(undefined)
+      expect(cookie['options'].maxage).toBe(365)
+      expect(cookie['options'].path).toBe('/')
+      expect(cookie['options'].sameSite).toBe('Lax')
+      expect(cookie['options'].secure).toBe(undefined)
+    })
+
+    it('should set options properly', () => {
+      const cookie = new CookieStorage({
+        domain: 'foo',
+        secure: true,
+        path: '/test',
+      })
+      expect(cookie['options'].domain).toBe('foo')
+      expect(cookie['options'].secure).toBe(true)
+      expect(cookie['options'].path).toBe('/test')
+      expect(cookie['options'].secure).toBe(true)
+    })
+
+    it('should pass options when creating cookie', () => {
+      const jarSpy = jest.spyOn(jar, 'set')
+      const cookie = new CookieStorage({
+        domain: 'foo',
+        secure: true,
+        path: '/test',
+      })
+
+      cookie.set('foo', 'bar')
+
+      expect(jarSpy).toHaveBeenCalledWith('foo', 'bar', {
+        domain: 'foo',
+        expires: 365,
+        path: '/test',
+        sameSite: 'Lax',
+        secure: true,
+      })
+    })
+  })
+})

package/packages/browser/src/core/storage/__tests__/localStorage.test.ts

@@ -0,0 +1,70 @@
+import { LocalStorage } from '../localStorage'
+
+describe('LocalStorage', function () {
+  let store: LocalStorage
+
+  beforeEach(() => {
+    jest.spyOn(console, 'warn').mockImplementation(() => {}) // silence console spam.
+    store = new LocalStorage()
+  })
+
+  afterEach(() => {
+    localStorage.clear()
+  })
+
+  describe('#get', function () {
+    it('should return null if localStorage throws an error (or does not exist)', function () {
+      const getItemSpy = jest
+        .spyOn(global.Storage.prototype, 'getItem')
+        .mockImplementationOnce(() => {
+          throw new Error('getItem fail.')
+        })
+      store.set('foo', 'some value')
+      expect(store.get('foo')).toBeNull()
+      expect(getItemSpy).toBeCalledTimes(1)
+    })
+
+    it('should not get an empty record', function () {
+      expect(store.get('abc')).toBe(null)
+    })
+
+    it('should get an existing record', function () {
+      store.set('x', { a: 'b' })
+      store.set('a', 'hello world')
+      store.set('b', '')
+      store.set('c', false)
+      store.set('d', null)
+      store.set('e', undefined)
+
+      expect(store.get('x')).toStrictEqual({ a: 'b' })
+      expect(store.get('a')).toBe('hello world')
+      expect(store.get('b')).toBe('')
+      expect(store.get('c')).toBe(false)
+      expect(store.get('d')).toBe(null)
+      expect(store.get('e')).toBe('undefined')
+    })
+  })
+
+  describe('#set', function () {
+    it('should be able to set a record', function () {
+      store.set('x', { a: 'b' })
+      expect(store.get('x')).toStrictEqual({ a: 'b' })
+    })
+
+    it('should catch localStorage quota exceeded errors', () => {
+      const val = 'x'.repeat(10 * 1024 * 1024)
+      store.set('foo', val)
+
+      expect(store.get('foo')).toBe(null)
+    })
+  })
+
+  describe('#clear', function () {
+    it('should be able to remove a record', function () {
+      store.set('x', { a: 'b' })
+      expect(store.get('x')).toStrictEqual({ a: 'b' })
+      store.remove('x')
+      expect(store.get('x')).toBe(null)
+    })
+  })
+})

package/packages/browser/src/core/storage/__tests__/test-helpers.ts

@@ -0,0 +1,26 @@
+import jar from 'js-cookie'
+const throwDisabledError = () => {
+  throw new Error('__sorry brah, this storage is disabled__')
+}
+/**
+ * Disables Cookies
+ * @returns jest spy
+ */
+export function disableCookies(): void {
+  jest.spyOn(window.navigator, 'cookieEnabled', 'get').mockReturnValue(false)
+  jest.spyOn(jar, 'set').mockImplementation(throwDisabledError)
+  jest.spyOn(jar, 'get').mockImplementation(throwDisabledError)
+}
+
+/**
+ * Disables LocalStorage
+ * @returns jest spy
+ */
+export function disableLocalStorage(): void {
+  jest
+    .spyOn(Storage.prototype, 'setItem')
+    .mockImplementation(throwDisabledError)
+  jest
+    .spyOn(Storage.prototype, 'getItem')
+    .mockImplementation(throwDisabledError)
+}

package/packages/browser/src/core/storage/__tests__/universalStorage.test.ts

@@ -0,0 +1,167 @@
+import jar from 'js-cookie'
+import { CookieStorage } from '../cookieStorage'
+import { LocalStorage } from '../localStorage'
+import { MemoryStorage } from '../memoryStorage'
+import { UniversalStorage } from '../universalStorage'
+import { disableCookies, disableLocalStorage } from './test-helpers'
+
+describe('UniversalStorage', function () {
+  const defaultTargets = [
+    new CookieStorage(),
+    new LocalStorage(),
+    new MemoryStorage(),
+  ]
+  const getFromLS = (key: string) => JSON.parse(localStorage.getItem(key) ?? '')
+  jest.spyOn(console, 'warn').mockImplementation(() => {
+    // avoid accidental noise in console
+    throw new Error('console.warn should be mocked!')
+  })
+
+  beforeEach(function () {
+    jest.restoreAllMocks()
+    clear()
+  })
+
+  function clear(): void {
+    document.cookie.split(';').forEach(function (c) {
+      document.cookie = c
+        .replace(/^ +/, '')
+        .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/')
+    })
+    localStorage.clear()
+  }
+
+  describe('#get', function () {
+    it('picks data from cookies first', function () {
+      jar.set('ajs_test_key', '🍪')
+      localStorage.setItem('ajs_test_key', '💾')
+      const us = new UniversalStorage(defaultTargets)
+      expect(us.get('ajs_test_key')).toEqual('🍪')
+    })
+
+    it('picks data from localStorage if there is no cookie target', function () {
+      jar.set('ajs_test_key', '🍪')
+      localStorage.setItem('ajs_test_key', '💾')
+      const us = new UniversalStorage([new LocalStorage(), new MemoryStorage()])
+      expect(us.get('ajs_test_key')).toEqual('💾')
+    })
+
+    it('get data from memory', function () {
+      jar.set('ajs_test_key', '🍪')
+      localStorage.setItem('ajs_test_key', '💾')
+      const us = new UniversalStorage([new MemoryStorage()])
+      expect(us.get('ajs_test_key')).toBeNull()
+    })
+
+    it('order of default targets matters!', function () {
+      jar.set('ajs_test_key', '🍪')
+      localStorage.setItem('ajs_test_key', '💾')
+      const us = new UniversalStorage([
+        new LocalStorage(),
+        new CookieStorage(),
+        new MemoryStorage(),
+      ])
+      expect(us.get('ajs_test_key')).toEqual('💾')
+    })
+
+    it('returns null if there are no storage targets', function () {
+      jar.set('ajs_test_key', '🍪')
+      localStorage.setItem('ajs_test_key', '💾')
+      const us = new UniversalStorage([])
+      expect(us.get('ajs_test_key')).toBeNull()
+    })
+  })
+
+  describe('#set', function () {
+    it('sets the data in all storage types', function () {
+      const us = new UniversalStorage<{ ajs_test_key: string }>(defaultTargets)
+      us.set('ajs_test_key', '💰')
+      expect(jar.get('ajs_test_key')).toEqual('💰')
+      expect(getFromLS('ajs_test_key')).toEqual('💰')
+    })
+
+    it('skip saving data to localStorage', function () {
+      const us = new UniversalStorage([
+        new CookieStorage(),
+        new MemoryStorage(),
+      ])
+      us.set('ajs_test_key', '💰')
+      expect(jar.get('ajs_test_key')).toEqual('💰')
+      expect(localStorage.getItem('ajs_test_key')).toEqual(null)
+    })
+
+    it('skip saving data to cookie', function () {
+      const us = new UniversalStorage([new LocalStorage(), new MemoryStorage()])
+      us.set('ajs_test_key', '💰')
+      expect(jar.get('ajs_test_key')).toEqual(undefined)
+      expect(getFromLS('ajs_test_key')).toEqual('💰')
+    })
+
+    it('can save and retrieve from memory when there is no other storage', function () {
+      const us = new UniversalStorage([new MemoryStorage()])
+      us.set('ajs_test_key', '💰')
+      expect(jar.get('ajs_test_key')).toEqual(undefined)
+      expect(localStorage.getItem('ajs_test_key')).toEqual(null)
+      expect(us.get('ajs_test_key')).toEqual('💰')
+    })
+
+    it('handles cookie errors gracefully', function () {
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {})
+
+      disableCookies() // Cookies is going to throw exceptions now
+      const us = new UniversalStorage([
+        new LocalStorage(),
+        new CookieStorage(),
+        new MemoryStorage(),
+      ])
+      us.set('ajs_test_key', '💰')
+      expect(getFromLS('ajs_test_key')).toEqual('💰')
+      expect(us.get('ajs_test_key')).toEqual('💰')
+      expect(consoleWarnSpy.mock.calls.length).toEqual(1)
+      expect(consoleWarnSpy.mock.lastCall[0]).toContain(
+        "CookieStorage: Can't set key"
+      )
+    })
+
+    it('does not write to LS when LS is not available', function () {
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {})
+
+      disableLocalStorage() // Localstorage will throw exceptions
+      const us = new UniversalStorage([
+        new LocalStorage(),
+        new CookieStorage(),
+        new MemoryStorage(),
+      ])
+      us.set('ajs_test_key', '💰')
+      expect(jar.get('ajs_test_key')).toEqual('💰')
+      expect(us.get('ajs_test_key')).toEqual('💰')
+      expect(consoleWarnSpy.mock.lastCall[0]).toContain('localStorage')
+    })
+
+    it('handles cookie getter overrides gracefully', function () {
+      const consoleWarnSpy = jest
+        .spyOn(console, 'warn')
+        .mockImplementation(() => {})
+
+      ;(document as any).__defineGetter__('cookie', function () {
+        return ''
+      })
+      const us = new UniversalStorage([
+        new LocalStorage(),
+        new CookieStorage(),
+        new MemoryStorage(),
+      ])
+      us.set('ajs_test_key', '💰')
+      expect(getFromLS('ajs_test_key')).toEqual('💰')
+      expect(us.get('ajs_test_key')).toEqual('💰')
+      expect(consoleWarnSpy.mock.lastCall[0]).toContain(
+        "CookieStorage: Can't set key"
+      )
+      expect(consoleWarnSpy.mock.lastCall[0]).toContain('TypeError')
+    })
+  })
+})