@openobserve/browser-core 0.3.2 → 0.3.3

package/src/domain/console/consoleObservable.spec.ts

@@ -1,151 +0,0 @@
-/* eslint-disable no-console */
-import { ignoreConsoleLogs } from '../../../test'
-import { ConsoleApiName } from '../../tools/display'
-import type { Subscription } from '../../tools/observable'
-import type { ErrorConsoleLog } from './consoleObservable'
-import { initConsoleObservable } from './consoleObservable'
-
-// prettier: avoid formatting issue
-// cf https://github.com/prettier/prettier/issues/12211
-;[
-  { api: ConsoleApiName.log },
-  { api: ConsoleApiName.info },
-  { api: ConsoleApiName.warn },
-  { api: ConsoleApiName.debug },
-  { api: ConsoleApiName.error },
-].forEach(({ api }) => {
-  describe(`console ${api} observable`, () => {
-    let consoleSpy: jasmine.Spy
-    let consoleSubscription: Subscription
-    let notifyLog: jasmine.Spy
-
-    beforeEach(() => {
-      consoleSpy = spyOn(console, api)
-      notifyLog = jasmine.createSpy('notifyLog')
-
-        consoleSubscription = initConsoleObservable([api]).subscribe(notifyLog)
-      })
-
-      afterEach(() => {
-        consoleSubscription.unsubscribe()
-      })
-
-      it(`should notify ${api}`, () => {
-        console[api]('foo', 'bar')
-
-        const consoleLog = notifyLog.calls.mostRecent().args[0]
-
-      expect(consoleLog).toEqual(
-        jasmine.objectContaining({
-          message: 'foo bar',
-          api,
-        })
-      )
-    })
-
-      it('should keep original behavior', () => {
-        console[api]('foo', 'bar')
-
-      expect(consoleSpy).toHaveBeenCalledWith('foo', 'bar')
-    })
-
-    it('should format error instance', () => {
-      console[api](new TypeError('hello'))
-      const consoleLog = notifyLog.calls.mostRecent().args[0]
-      expect(consoleLog.message).toBe('TypeError: hello')
-    })
-
-    it('should stringify object parameters', () => {
-      console[api]('Hello', { foo: 'bar' })
-      const consoleLog = notifyLog.calls.mostRecent().args[0]
-      expect(consoleLog.message).toBe('Hello {\n  "foo": "bar"\n}')
-    })
-
-      it('should allow multiple callers', () => {
-        const notifyOtherCaller = jasmine.createSpy('notifyOtherCaller')
-        const instrumentedConsoleApi = console[api]
-        const otherConsoleSubscription = initConsoleObservable([api]).subscribe(notifyOtherCaller)
-
-        console[api]('foo', 'bar')
-
-        expect(instrumentedConsoleApi).toEqual(console[api])
-        expect(notifyLog).toHaveBeenCalledTimes(1)
-        expect(notifyOtherCaller).toHaveBeenCalledTimes(1)
-
-        otherConsoleSubscription.unsubscribe()
-      })
-    })
-  })
-
-describe('console error observable', () => {
-  let consoleSubscription: Subscription
-  let notifyLog: jasmine.Spy<(consoleLog: ErrorConsoleLog) => void>
-
-  beforeEach(() => {
-    ignoreConsoleLogs('error', 'Error: foo')
-    ignoreConsoleLogs('error', 'foo bar')
-    notifyLog = jasmine.createSpy('notifyLog')
-
-    consoleSubscription = initConsoleObservable([ConsoleApiName.error]).subscribe(notifyLog)
-  })
-
-  afterEach(() => {
-    consoleSubscription.unsubscribe()
-  })
-
-  it('should generate a handling stack', () => {
-    function triggerError() {
-      console.error('foo', 'bar')
-    }
-    triggerError()
-    const consoleLog = notifyLog.calls.mostRecent().args[0]
-    expect(consoleLog.handlingStack).toMatch(/^HandlingStack: console error\s+at triggerError (.|\n)*$/)
-  })
-
-  it('should extract stack from first error', () => {
-    console.error(new TypeError('foo'), new TypeError('bar'))
-    const stack = notifyLog.calls.mostRecent().args[0].error.stack
-    expect(stack).toContain('TypeError: foo')
-  })
-
-  it('should retrieve fingerprint from error', () => {
-    interface DatadogError extends Error {
-      oo_fingerprint?: string
-    }
-    const error = new Error('foo')
-      ; (error as DatadogError).oo_fingerprint = 'my-fingerprint'
-
-    console.error(error)
-
-    const consoleLog = notifyLog.calls.mostRecent().args[0]
-    expect(consoleLog.error.fingerprint).toBe('my-fingerprint')
-  })
-
-  it('should sanitize error fingerprint', () => {
-    const error = new Error('foo')
-      ; (error as any).oo_fingerprint = 2
-
-    console.error(error)
-
-    const consoleLog = notifyLog.calls.mostRecent().args[0]
-    expect(consoleLog.error.fingerprint).toBe('2')
-  })
-
-  it('should retrieve context from error', () => {
-    interface DatadogError extends Error {
-      dd_context?: Record<string, unknown>
-    }
-    const error = new Error('foo')
-    ;(error as DatadogError).dd_context = { foo: 'bar' }
-    console.error(error)
-    const consoleLog = notifyLog.calls.mostRecent().args[0]
-    expect(consoleLog.error.context).toEqual({ foo: 'bar' })
-  })
-
-  it('should report original error', () => {
-    const error = new Error('foo')
-    console.error(error)
-    const consoleLog = notifyLog.calls.mostRecent().args[0]
-    expect(consoleLog.error.originalError).toBe(error)
-  })
-})

package/src/domain/context/contextManager.spec.ts

@@ -1,152 +0,0 @@
-import { display } from '../../tools/display'
-import type { PropertiesConfig } from './contextManager'
-import { createContextManager } from './contextManager'
-
-function createContextManagerWithDefaults(propertiesConfig?: PropertiesConfig) {
-  return createContextManager('test', { propertiesConfig })
-}
-
-describe('createContextManager', () => {
-  it('starts with an empty context', () => {
-    const manager = createContextManagerWithDefaults()
-    expect(manager.getContext()).toEqual({})
-  })
-
-  it('updates the context', () => {
-    const manager = createContextManagerWithDefaults()
-    manager.setContext({ bar: 'foo' })
-
-    expect(manager.getContext()).toEqual({ bar: 'foo' })
-  })
-
-  it('completely replaces the context', () => {
-    const manager = createContextManagerWithDefaults()
-    manager.setContext({ a: 'foo' })
-    expect(manager.getContext()).toEqual({ a: 'foo' })
-    manager.setContext({ b: 'foo' })
-    expect(manager.getContext()).toEqual({ b: 'foo' })
-  })
-
-  it('sets a context value', () => {
-    const manager = createContextManagerWithDefaults()
-    manager.setContextProperty('foo', 'bar')
-    expect(manager.getContext()).toEqual({ foo: 'bar' })
-  })
-
-  it('removes a context value', () => {
-    const manager = createContextManagerWithDefaults()
-    manager.setContext({ a: 'foo', b: 'bar' })
-    manager.removeContextProperty('a')
-    expect(manager.getContext()).toEqual({ b: 'bar' })
-    manager.removeContextProperty('b')
-    expect(manager.getContext()).toEqual({})
-  })
-
-  it('should get a clone of the context from getContext', () => {
-    const manager = createContextManagerWithDefaults()
-    expect(manager.getContext()).toEqual(manager.getContext())
-    expect(manager.getContext()).not.toBe(manager.getContext())
-  })
-
-  it('should set a clone of context via setContext', () => {
-    const nestedObject = { foo: 'bar' }
-    const context = { nested: nestedObject }
-    const manager = createContextManagerWithDefaults()
-    manager.setContext(context)
-    expect(manager.getContext().nested).toEqual(nestedObject)
-    expect(manager.getContext().nested).not.toBe(nestedObject)
-  })
-
-  it('should set a clone of the property via setContextProperty', () => {
-    const nestedObject = { foo: 'bar' }
-    const manager = createContextManagerWithDefaults()
-    manager.setContextProperty('nested', nestedObject)
-    expect(manager.getContext().nested).toEqual(nestedObject)
-    expect(manager.getContext().nested).not.toBe(nestedObject)
-  })
-
-  it('should clear context object via clearContext', () => {
-    const context = { foo: 'bar' }
-    const manager = createContextManagerWithDefaults()
-    manager.setContext(context)
-    expect(manager.getContext()).toEqual(context)
-    manager.clearContext()
-    expect(manager.getContext()).toEqual({})
-  })
-
-  it('should prevent setting non object values', () => {
-    spyOn(display, 'error')
-    const manager = createContextManagerWithDefaults()
-    manager.setContext(null as any)
-    expect(manager.getContext()).toEqual({})
-    manager.setContext(undefined as any)
-    expect(manager.getContext()).toEqual({})
-    manager.setContext(2 as any)
-    expect(manager.getContext()).toEqual({})
-  })
-
-  describe('type enforcement', () => {
-    const NULLISH_VALUES = [undefined, null, '']
-
-    it('should enforce specified type on properties', () => {
-      const manager = createContextManagerWithDefaults({
-        id: { type: 'string' },
-        name: { type: 'string' },
-        email: { type: 'string' },
-      })
-
-      manager.setContext({ id: 42, name: true, email: {} })
-
-      expect(manager.getContext()).toEqual({ id: '42', name: 'true', email: '[object Object]' })
-    })
-
-    it('should not enforce specified type on null or undefined properties', () => {
-      const manager = createContextManagerWithDefaults({
-        id: { type: 'string' },
-        name: { type: 'string' },
-      })
-
-      manager.setContext({ id: undefined, name: null })
-      expect(manager.getContext()).toEqual({ id: undefined, name: null })
-    })
-
-    NULLISH_VALUES.forEach((value) => {
-      it(`should warn when required property is  ${value}`, () => {
-        const displaySpy = spyOn(display, 'warn')
-
-        const manager = createContextManagerWithDefaults({
-          id: { required: true },
-        })
-
-        manager.setContext({ id: value })
-
-        expect(displaySpy).toHaveBeenCalledOnceWith(
-          'The property id of test is required; context will not be sent to the intake.'
-        )
-      })
-    })
-  })
-
-  describe('changeObservable', () => {
-    it('should notify on context changes', () => {
-      const changeSpy = jasmine.createSpy('change')
-      const manager = createContextManagerWithDefaults()
-      manager.changeObservable.subscribe(changeSpy)
-
-      manager.getContext()
-      expect(changeSpy).not.toHaveBeenCalled()
-
-      manager.setContext({ foo: 'bar' })
-      expect(changeSpy).toHaveBeenCalledTimes(1)
-
-      manager.setContextProperty('qux', 'qix')
-      expect(changeSpy).toHaveBeenCalledTimes(2)
-
-      manager.removeContextProperty('qux')
-      expect(changeSpy).toHaveBeenCalledTimes(3)
-
-      manager.clearContext()
-      expect(changeSpy).toHaveBeenCalledTimes(4)
-    })
-  })
-})

package/src/domain/context/contextUtils.spec.ts

@@ -1,26 +0,0 @@
-import { display } from '../../tools/display'
-import type { Context } from '../../tools/serialisation/context'
-import type { Account } from '../contexts/accountContext'
-import type { User } from '../contexts/userContext'
-import { checkContext } from './contextUtils'
-
-describe('checkContext function', () => {
-  it('should only accept valid objects', () => {
-    spyOn(display, 'error')
-
-    const obj: any = { id: 42, name: true, email: null } // Valid, even though not sanitized
-    const user: User = { id: '42', name: 'John', email: 'john@doe.com' }
-    const account: Account = { id: '42', name: 'Groupe' }
-    const undefUser: any = undefined
-    const nullUser: any = null
-    const invalidUser: any = 42
-
-    expect(checkContext(obj)).toBe(true)
-    expect(checkContext(user as Context)).toBe(true)
-    expect(checkContext(account as Context)).toBe(true)
-    expect(checkContext(undefUser)).toBe(false)
-    expect(checkContext(nullUser)).toBe(false)
-    expect(checkContext(invalidUser)).toBe(false)
-    expect(display.error).toHaveBeenCalledTimes(3)
-  })
-})

package/src/domain/context/storeContextManager.spec.ts

@@ -1,103 +0,0 @@
-import type { Configuration } from '../configuration'
-import { createNewEvent } from '../../../test'
-import { DOM_EVENT } from '../../browser/addEventListener'
-import type { Context } from '../../tools/serialisation/context'
-import { storeContextManager, buildStorageKey, removeStorageListeners } from './storeContextManager'
-import { CustomerDataType } from './contextConstants'
-import { createContextManager } from './contextManager'
-
-describe('storeContextManager', () => {
-  const PRODUCT_KEY = 'fake'
-  const CUSTOMER_DATA_TYPE = CustomerDataType.User
-  const STORAGE_KEY = buildStorageKey(PRODUCT_KEY, CUSTOMER_DATA_TYPE)
-
-  let configuration: Configuration
-
-  beforeEach(() => {
-    configuration = {} as Configuration
-  })
-
-  afterEach(() => {
-    localStorage.clear()
-    removeStorageListeners()
-  })
-
-  it('should synchronize with local storage at start', () => {
-    localStorage.setItem(STORAGE_KEY, '{"bar":"foo"}')
-
-    const manager = createStoredContextManager()
-
-    expect(manager.getContext()).toEqual({ bar: 'foo' })
-  })
-
-  it('should synchronize with local storage on storage events', () => {
-    const manager = createStoredContextManager()
-
-    localStorage.setItem(STORAGE_KEY, '{"bar":"foo"}')
-    expect(manager.getContext()).toEqual({})
-
-    window.dispatchEvent(createNewEvent(DOM_EVENT.STORAGE, { key: 'unknown' }))
-    expect(manager.getContext()).toEqual({})
-
-    window.dispatchEvent(createNewEvent(DOM_EVENT.STORAGE, { key: STORAGE_KEY }))
-    expect(manager.getContext()).toEqual({ bar: 'foo' })
-  })
-
-  it('should update local storage on context updates', () => {
-    const manager = createStoredContextManager()
-    expect(localStorage.getItem(STORAGE_KEY)).toBe(null)
-
-    manager.setContext({ bar: 'foo' })
-    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo"}')
-
-    manager.setContextProperty('qux', 'qix')
-    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo","qux":"qix"}')
-
-    manager.removeContextProperty('qux')
-    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo"}')
-
-    manager.clearContext()
-    expect(localStorage.getItem(STORAGE_KEY)).toBe('{}')
-  })
-
-  it('merges local storage data with initial context', () => {
-    localStorage.setItem(STORAGE_KEY, '{"bar":"foo"}')
-    const manager = createStoredContextManager({ initialContext: { qux: 'qix' } })
-
-    expect(manager.getContext()).toEqual({ bar: 'foo', qux: 'qix' })
-    expect(localStorage.getItem(STORAGE_KEY)).toBe('{"bar":"foo","qux":"qix"}')
-  })
-
-  it('should store different product data in different storage key', () => {
-    createStoredContextManager({ initialContext: { bar: 'foo' }, productKey: 'p1' })
-    createStoredContextManager({ initialContext: { qux: 'qix' }, productKey: 'p2' })
-
-    expect(localStorage.getItem(buildStorageKey('p1', CUSTOMER_DATA_TYPE))).toBe('{"bar":"foo"}')
-    expect(localStorage.getItem(buildStorageKey('p2', CUSTOMER_DATA_TYPE))).toBe('{"qux":"qix"}')
-  })
-
-  it('should store different data type in different storage key', () => {
-    createStoredContextManager({ initialContext: { bar: 'foo' }, customerDataType: CustomerDataType.User })
-    createStoredContextManager({ initialContext: { qux: 'qix' }, customerDataType: CustomerDataType.GlobalContext })
-
-    expect(localStorage.getItem(buildStorageKey(PRODUCT_KEY, CustomerDataType.User))).toBe('{"bar":"foo"}')
-    expect(localStorage.getItem(buildStorageKey(PRODUCT_KEY, CustomerDataType.GlobalContext))).toBe('{"qux":"qix"}')
-  })
-
-  function createStoredContextManager({
-    initialContext,
-    productKey = PRODUCT_KEY,
-    customerDataType = CUSTOMER_DATA_TYPE,
-  }: {
-    initialContext?: Context
-    productKey?: string
-    customerDataType?: CustomerDataType
-  } = {}) {
-    const manager = createContextManager('test')
-    if (initialContext) {
-      manager.setContext(initialContext)
-    }
-    storeContextManager(configuration, manager, productKey, customerDataType)
-    return manager
-  }
-})

package/src/domain/contexts/accountContext.spec.ts

@@ -1,99 +0,0 @@
-import type { Hooks } from '../../../test'
-import { createHooks, registerCleanupTask } from '../../../test'
-import { mockRumConfiguration } from '../../../../rum-core/test'
-import type { ContextManager } from '../context/contextManager'
-import { display } from '../../tools/display'
-import type { RelativeTime } from '../../tools/utils/timeUtils'
-import { HookNames } from '../../tools/abstractHooks'
-import { removeStorageListeners } from '../context/storeContextManager'
-import { startAccountContext } from './accountContext'
-
-describe('account context', () => {
-  let accountContext: ContextManager
-  let displaySpy: jasmine.Spy
-  let hooks: Hooks
-
-  beforeEach(() => {
-    hooks = createHooks()
-    displaySpy = spyOn(display, 'warn')
-
-    accountContext = startAccountContext(hooks, mockRumConfiguration(), 'some_product_key')
-  })
-
-  it('should warn when the account.id is missing', () => {
-    accountContext.setContext({ foo: 'bar' })
-    expect(displaySpy).toHaveBeenCalled()
-  })
-
-  it('should sanitize predefined properties', () => {
-    accountContext.setContext({ id: false, name: 2 })
-    expect(accountContext.getContext()).toEqual({
-      id: 'false',
-      name: '2',
-    })
-  })
-
-  describe('assemble hook', () => {
-    it('should set the account', () => {
-      accountContext.setContext({ id: '123', foo: 'bar' })
-
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
-        startTime: 0 as RelativeTime,
-      })
-
-      expect(defaultRumEventAttributes).toEqual({
-        account: {
-          id: '123',
-          foo: 'bar',
-        },
-      })
-    })
-
-    it('should not set the account when account.id is undefined', () => {
-      accountContext.setContext({ foo: 'bar' })
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
-        eventType: 'view',
-        startTime: 0 as RelativeTime,
-      })
-
-      expect(defaultRumEventAttributes).toBeUndefined()
-    })
-  })
-})
-
-describe('account context across pages', () => {
-  let accountContext: ContextManager
-  let hooks: Hooks
-  beforeEach(() => {
-    hooks = createHooks()
-
-    registerCleanupTask(() => {
-      localStorage.clear()
-      removeStorageListeners()
-    })
-  })
-
-  it('when disabled, should store contexts only in memory', () => {
-    accountContext = startAccountContext(
-      hooks,
-      mockRumConfiguration({ storeContextsAcrossPages: false }),
-      'some_product_key'
-    )
-    accountContext.setContext({ id: '123' })
-
-    expect(accountContext.getContext()).toEqual({ id: '123' })
-    expect(localStorage.getItem('_oo_c_rum_4')).toBeNull()
-  })
-
-  it('when enabled, should maintain the account in local storage', () => {
-    accountContext = startAccountContext(
-      hooks,
-      mockRumConfiguration({ storeContextsAcrossPages: true }),
-      'some_product_key'
-    )
-
-    accountContext.setContext({ id: 'foo', qux: 'qix' })
-    expect(accountContext.getContext()).toEqual({ id: 'foo', qux: 'qix' })
-    expect(localStorage.getItem('_oo_c_some_product_key_4')).toBe('{"id":"foo","qux":"qix"}')
-  })
-})

package/src/domain/contexts/globalContext.spec.ts

@@ -1,88 +0,0 @@
-import type { Hooks } from '../../../test'
-import type { LogsConfiguration } from '../../../../logs/src/domain/configuration'
-import type { ContextManager } from '../context/contextManager'
-import { HookNames } from '../../tools/abstractHooks'
-import type { RelativeTime } from '../../tools/utils/timeUtils'
-import { createHooks, registerCleanupTask } from '../../../test'
-import { removeStorageListeners } from '../context/storeContextManager'
-import type { Configuration } from '../configuration'
-import { startGlobalContext } from './globalContext'
-
-describe('logs global context', () => {
-  let globalContext: ContextManager
-  let hooks: Hooks
-
-  beforeEach(() => {
-    hooks = createHooks()
-  })
-
-  describe('assemble hook', () => {
-    it('should set the context in context in `context` namespace when specified', () => {
-      const contextNamespace = true
-      globalContext = startGlobalContext(hooks, {} as LogsConfiguration, 'some_product_key', contextNamespace)
-
-      globalContext.setContext({ id: '123', foo: 'bar' })
-      const event = hooks.triggerHook(HookNames.Assemble, { startTime: 0 as RelativeTime })
-
-      expect(event).toEqual({
-        context: {
-          id: '123',
-          foo: 'bar',
-        },
-      })
-    })
-
-    it('should set the context in root namespace when specified', () => {
-      const contextNamespace = false
-      globalContext = startGlobalContext(hooks, {} as LogsConfiguration, 'some_product_key', contextNamespace)
-
-      globalContext.setContext({ id: '123', foo: 'bar' })
-      const event = hooks.triggerHook(HookNames.Assemble, { startTime: 0 as RelativeTime })
-
-      expect(event).toEqual({
-        id: '123',
-        foo: 'bar',
-      })
-    })
-  })
-})
-
-describe('global context across pages', () => {
-  let globalContext: ContextManager
-  let hooks: Hooks
-
-  beforeEach(() => {
-    hooks = createHooks()
-
-    registerCleanupTask(() => {
-      localStorage.clear()
-      removeStorageListeners()
-    })
-  })
-
-  it('when disabled, should store contexts only in memory', () => {
-    globalContext = startGlobalContext(
-      hooks,
-      { storeContextsAcrossPages: false } as Configuration,
-      'some_product_key',
-      false
-    )
-    globalContext.setContext({ id: '123' })
-
-    expect(globalContext.getContext()).toEqual({ id: '123' })
-    expect(localStorage.getItem('_oo_c_some_product_key_2')).toBeNull()
-  })
-
-  it('when enabled, should maintain the global context in local storage', () => {
-    globalContext = startGlobalContext(
-      hooks,
-      { storeContextsAcrossPages: true } as Configuration,
-      'some_product_key',
-      false
-    )
-
-    globalContext.setContext({ id: 'foo', qux: 'qix' })
-    expect(globalContext.getContext()).toEqual({ id: 'foo', qux: 'qix' })
-    expect(localStorage.getItem('_oo_c_some_product_key_2')).toBe('{"id":"foo","qux":"qix"}')
-  })
-})