@openobserve/browser-core 0.2.12-beta.9 → 0.3.1

package/src/tools/abstractLifeCycle.spec.ts

@@ -0,0 +1,46 @@
+import { AbstractLifeCycle } from './abstractLifeCycle'
+
+describe('AbstractLifeCycle', () => {
+  const LifeCycle = AbstractLifeCycle<{
+    foo: 'bar'
+    no_data: void
+  }>
+
+  it('does nothing when notifying without subscribers', () => {
+    const lifeCycle = new LifeCycle()
+    expect(() => lifeCycle.notify('foo', 'bar')).not.toThrow()
+  })
+
+  it('notifies subscribers', () => {
+    const lifeCycle = new LifeCycle()
+    const subscriber1Spy = jasmine.createSpy()
+    const subscriber2Spy = jasmine.createSpy()
+    lifeCycle.subscribe('foo', subscriber1Spy)
+    lifeCycle.subscribe('foo', subscriber2Spy)
+
+    lifeCycle.notify('foo', 'bar')
+
+    expect(subscriber1Spy).toHaveBeenCalledOnceWith('bar')
+    expect(subscriber2Spy).toHaveBeenCalledOnceWith('bar')
+  })
+
+  it('notifies subscribers for events without data', () => {
+    const lifeCycle = new LifeCycle()
+    const subscriberSpy = jasmine.createSpy()
+    lifeCycle.subscribe('no_data', subscriberSpy)
+
+    lifeCycle.notify('no_data')
+
+    expect(subscriberSpy).toHaveBeenCalledOnceWith(undefined)
+  })
+
+  it('does not notify unsubscribed subscribers', () => {
+    const lifeCycle = new LifeCycle()
+    const subscriberSpy = jasmine.createSpy()
+    lifeCycle.subscribe('foo', subscriberSpy).unsubscribe()
+
+    lifeCycle.notify('foo', 'bar')
+
+    expect(subscriberSpy).not.toHaveBeenCalled()
+  })
+})

package/src/tools/boundedBuffer.spec.ts

@@ -0,0 +1,40 @@
+import { createBoundedBuffer } from './boundedBuffer'
+
+describe('BoundedBuffer', () => {
+  it('collect and drain the callbacks', () => {
+    const spy = jasmine.createSpy<() => void>()
+    const buffered = createBoundedBuffer()
+
+    buffered.add(spy)
+    expect(spy.calls.count()).toBe(0)
+
+    buffered.drain()
+    expect(spy.calls.count()).toBe(1)
+
+    buffered.drain()
+    expect(spy.calls.count()).toBe(1)
+  })
+
+  it('store at most 500 callbacks', () => {
+    const spy = jasmine.createSpy<() => void>()
+    const buffered = createBoundedBuffer()
+    const limit = 500
+
+    for (let i = 0; i < limit + 1; i += 1) {
+      buffered.add(spy)
+    }
+
+    buffered.drain()
+    expect(spy.calls.count()).toEqual(limit)
+  })
+
+  it('removes a callback', () => {
+    const spy = jasmine.createSpy<() => void>()
+    const buffered = createBoundedBuffer()
+
+    buffered.add(spy)
+    buffered.remove(spy)
+    buffered.drain()
+    expect(spy).not.toHaveBeenCalled()
+  })
+})

package/src/tools/catchUserErrors.spec.ts

@@ -0,0 +1,20 @@
+import { catchUserErrors } from './catchUserErrors'
+import { display } from './display'
+
+describe('catchUserErrors', () => {
+  it('returns the same result as the original function', () => {
+    const wrappedFn = catchUserErrors((a: number, b: number) => a + b, 'Error during callback')
+    expect(wrappedFn(10, 2)).toBe(12)
+  })
+
+  it('logs errors using console.error and returns undefined', () => {
+    const displaySpy = spyOn(display, 'error')
+    const myError = 'Ooops!'
+    const wrappedFn = catchUserErrors(() => {
+      // eslint-disable-next-line @typescript-eslint/only-throw-error
+      throw myError
+    }, 'Error during callback')
+    expect(wrappedFn()).toBe(undefined)
+    expect(displaySpy).toHaveBeenCalledWith('Error during callback', myError)
+  })
+})

package/src/tools/display.ts

@@ -41,7 +41,7 @@ Object.keys(ConsoleApiName).forEach((name) => {
   originalConsoleMethods[name as ConsoleApiName] = globalConsole[name as ConsoleApiName]
 })
 
-const PREFIX = 'Datadog Browser SDK:'
+const PREFIX = 'Openobserve Browser SDK:'
 
 export const display: Display = {
   debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),
@@ -51,6 +51,6 @@ export const display: Display = {
   error: originalConsoleMethods.error.bind(globalConsole, PREFIX),
 }
 
-export const DOCS_ORIGIN = 'https://docs.datadoghq.com'
-export const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`
+export const DOCS_ORIGIN = 'https://openobserve.ai'
+export const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/docs/user-guide/rum/`
 export const MORE_DETAILS = 'More details:'

package/src/tools/encoder.spec.ts

@@ -0,0 +1,112 @@
+import { createIdentityEncoder } from './encoder'
+import { noop } from './utils/functionUtils'
+
+describe('createIdentityEncoder', () => {
+  it('creates an encoder with initial values', () => {
+    const encoder = createIdentityEncoder()
+
+    expect(encoder.isEmpty).toBe(true)
+    expect(encoder.finishSync()).toEqual({
+      output: '',
+      outputBytesCount: 0,
+      rawBytesCount: 0,
+      pendingData: '',
+    })
+  })
+
+  describe('write()', () => {
+    it('writes data to the encoder', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Hello, world!'
+
+      encoder.write(data)
+
+      expect(encoder.isEmpty).toBe(false)
+    })
+
+    it('calls the callback when writing data with a callback', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Callback test'
+      const callbackSpy = jasmine.createSpy()
+
+      encoder.write(data, callbackSpy)
+
+      expect(callbackSpy).toHaveBeenCalledOnceWith(data.length)
+    })
+  })
+
+  describe('finish()', () => {
+    it('calls the callback with the result', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Final data'
+      encoder.write(data)
+      const callbackSpy = jasmine.createSpy()
+
+      encoder.finish(callbackSpy)
+
+      expect(callbackSpy).toHaveBeenCalledWith({
+        output: data,
+        outputBytesCount: data.length,
+        rawBytesCount: data.length,
+        pendingData: '',
+      })
+    })
+
+    it('after calling finish(), the encoder should be considered empty', () => {
+      const encoder = createIdentityEncoder()
+      encoder.write('Some data')
+
+      encoder.finish(noop)
+
+      expect(encoder.isEmpty).toBe(true)
+      expect(encoder.finishSync()).toEqual({
+        output: '',
+        outputBytesCount: 0,
+        rawBytesCount: 0,
+        pendingData: '',
+      })
+    })
+  })
+
+  describe('finishSync()', () => {
+    it('returns the encoder result', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Hello, world!'
+
+      encoder.write(data)
+
+      expect(encoder.finishSync()).toEqual({
+        output: data,
+        outputBytesCount: data.length,
+        rawBytesCount: data.length,
+        pendingData: '',
+      })
+    })
+
+    it('after calling finish(), the encoder should be considered empty', () => {
+      const encoder = createIdentityEncoder()
+      encoder.write('Some data')
+
+      encoder.finishSync()
+
+      expect(encoder.isEmpty).toBe(true)
+      expect(encoder.finishSync()).toEqual({
+        output: '',
+        outputBytesCount: 0,
+        rawBytesCount: 0,
+        pendingData: '',
+      })
+    })
+  })
+
+  describe('estimateEncodedBytesCount()', () => {
+    it('estimates encoded bytes count accurately', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Estimation test'
+
+      const estimatedBytes = encoder.estimateEncodedBytesCount(data)
+
+      expect(estimatedBytes).toBe(data.length)
+    })
+  })
+})

package/src/tools/experimentalFeatures.spec.ts

@@ -0,0 +1,60 @@
+import {
+  ExperimentalFeature,
+  addExperimentalFeatures,
+  initFeatureFlags,
+  isExperimentalFeatureEnabled,
+  resetExperimentalFeatures,
+} from './experimentalFeatures'
+
+const TEST_FEATURE_FLAG_ONE = 'foo' as ExperimentalFeature
+const TEST_FEATURE_FLAG_TWO = 'bar' as ExperimentalFeature
+
+describe('experimentalFeatures', () => {
+  afterEach(() => {
+    resetExperimentalFeatures()
+  })
+
+  it('initial state is empty', () => {
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeFalse()
+  })
+
+  it('should define enabled experimental features', () => {
+    addExperimentalFeatures([TEST_FEATURE_FLAG_ONE])
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeFalse()
+  })
+
+  it('should allow to be shared between products', () => {
+    addExperimentalFeatures([TEST_FEATURE_FLAG_ONE])
+    addExperimentalFeatures([TEST_FEATURE_FLAG_TWO])
+
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeTrue()
+  })
+})
+
+describe('initFeatureFlags', () => {
+  beforeEach(() => {
+    ;(ExperimentalFeature as any).FOO = TEST_FEATURE_FLAG_ONE
+  })
+
+  afterEach(() => {
+    delete (ExperimentalFeature as any).FOO
+    resetExperimentalFeatures()
+  })
+
+  it('ignores unknown experimental features', () => {
+    initFeatureFlags(['bar', undefined as any, null as any, 11 as any])
+
+    expect(isExperimentalFeatureEnabled('bar' as any)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(undefined as any)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(null as any)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(11 as any)).toBeFalse()
+  })
+
+  it('updates experimental feature flags', () => {
+    initFeatureFlags(['foo'])
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
+  })
+})

package/src/tools/getZoneJsOriginalValue.spec.ts

@@ -0,0 +1,36 @@
+import { mockZoneJs } from '../../test'
+
+import type { BrowserWindowWithZoneJs } from './getZoneJsOriginalValue'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+import { noop } from './utils/functionUtils'
+
+describe('getZoneJsOriginalValue', () => {
+  function originalValue() {
+    // just a function that does nothing but different than 'noop' as we'll want to differentiate
+    // them.
+  }
+  const object = {
+    name: originalValue,
+  }
+
+  it('returns the original value directly if Zone is not not defined', () => {
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+
+  it("returns the original value if Zone is defined but didn't patch that method", () => {
+    mockZoneJs()
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+
+  it('returns the original value if Zone is defined but does not define the __symbol__ function', () => {
+    mockZoneJs()
+    delete (window as BrowserWindowWithZoneJs).Zone!.__symbol__
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+
+  it('returns the original value if Zone did patch the method', () => {
+    const zoneJs = mockZoneJs()
+    zoneJs.replaceProperty(object, 'name', noop)
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+})