@openobserve/browser-core 0.3.3 → 0.3.4

package/cjs/boot/init.js

@@ -7,7 +7,7 @@ const monitor_1 = require("../tools/monitor");
 const display_1 = require("../tools/display");
 function makePublicApi(stub) {
     const publicApi = {
-        version: "0.3.3",
+        version: "0.3.4",
         // This API method is intentionally not monitored, since the only thing executed is the
         // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and
         // we don't want to interfere with the user uncaught exceptions.

package/cjs/domain/configuration/endpointBuilder.js

@@ -60,7 +60,7 @@ function buildEndpointParameters({ clientToken, internalAnalyticsSubdomain, sour
     const parameters = [
         `o2source=${source}`,
         `o2-api-key=${clientToken}`,
-        `o2-evp-origin-version=${encodeURIComponent("0.3.3")}`,
+        `o2-evp-origin-version=${encodeURIComponent("0.3.4")}`,
         'o2-evp-origin=browser',
         `o2-request-id=${(0, stringUtils_1.generateUUID)()}`,
     ].concat(extraParameters);

package/cjs/domain/tags.js

@@ -9,7 +9,7 @@ const display_1 = require("../tools/display");
 exports.TAG_SIZE_LIMIT = 200;
 function buildTags(configuration) {
     const { env, service, version, datacenter, sdkVersion, variant } = configuration;
-    const tags = [buildTag('sdk_version', sdkVersion !== null && sdkVersion !== void 0 ? sdkVersion : "0.3.3")];
+    const tags = [buildTag('sdk_version', sdkVersion !== null && sdkVersion !== void 0 ? sdkVersion : "0.3.4")];
     if (env) {
         tags.push(buildTag('env', env));
     }

package/cjs/domain/telemetry/telemetry.js

@@ -105,7 +105,7 @@ function startTelemetryCollection(telemetryService, configuration, hooks, observ
             type: 'telemetry',
             date: clockNow.timeStamp,
             service: telemetryService,
-            version: "0.3.3",
+            version: "0.3.4",
             source: 'browser',
             _oo: {
                 format_version: 2,

package/cjs/domain/telemetry/telemetryEvent.types.d.ts

@@ -218,7 +218,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
             /**
              * A list of selected tracing propagators
              */
-            selected_tracing_propagators?: ('tracecontext' | 'b3' | 'b3multi')[];
+            selected_tracing_propagators?: ('openobserve' | 'tracecontext' | 'b3' | 'b3multi')[];
             /**
              * Session replay default privacy level
              */

package/esm/boot/init.js

@@ -3,7 +3,7 @@ import { setDebugMode } from '../tools/monitor';
 import { display } from '../tools/display';
 export function makePublicApi(stub) {
     const publicApi = {
-        version: "0.3.3",
+        version: "0.3.4",
         // This API method is intentionally not monitored, since the only thing executed is the
         // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and
         // we don't want to interfere with the user uncaught exceptions.

package/esm/domain/configuration/endpointBuilder.js

@@ -56,7 +56,7 @@ function buildEndpointParameters({ clientToken, internalAnalyticsSubdomain, sour
     const parameters = [
         `o2source=${source}`,
         `o2-api-key=${clientToken}`,
-        `o2-evp-origin-version=${encodeURIComponent("0.3.3")}`,
+        `o2-evp-origin-version=${encodeURIComponent("0.3.4")}`,
         'o2-evp-origin=browser',
         `o2-request-id=${generateUUID()}`,
     ].concat(extraParameters);

package/esm/domain/tags.js

@@ -2,7 +2,7 @@ import { DOCS_ORIGIN, MORE_DETAILS, display } from '../tools/display';
 export const TAG_SIZE_LIMIT = 200;
 export function buildTags(configuration) {
     const { env, service, version, datacenter, sdkVersion, variant } = configuration;
-    const tags = [buildTag('sdk_version', sdkVersion !== null && sdkVersion !== void 0 ? sdkVersion : "0.3.3")];
+    const tags = [buildTag('sdk_version', sdkVersion !== null && sdkVersion !== void 0 ? sdkVersion : "0.3.4")];
     if (env) {
         tags.push(buildTag('env', env));
     }

package/esm/domain/telemetry/telemetry.js

@@ -92,7 +92,7 @@ export function startTelemetryCollection(telemetryService, configuration, hooks,
             type: 'telemetry',
             date: clockNow.timeStamp,
             service: telemetryService,
-            version: "0.3.3",
+            version: "0.3.4",
             source: 'browser',
             _oo: {
                 format_version: 2,

package/esm/domain/telemetry/telemetryEvent.types.d.ts

@@ -218,7 +218,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
             /**
              * A list of selected tracing propagators
              */
-            selected_tracing_propagators?: ('tracecontext' | 'b3' | 'b3multi')[];
+            selected_tracing_propagators?: ('openobserve' | 'tracecontext' | 'b3' | 'b3multi')[];
             /**
              * Session replay default privacy level
              */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openobserve/browser-core",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "license": "Apache-2.0",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,4 +24,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/boot/displayAlreadyInitializedError.spec.ts

@@ -0,0 +1,18 @@
+import type { InitConfiguration } from '../domain/configuration'
+import { display } from '../tools/display'
+import { displayAlreadyInitializedError } from './displayAlreadyInitializedError'
+
+describe('displayAlreadyInitializedError', () => {
+  it('should display an error', () => {
+    const displayErrorSpy = spyOn(display, 'error')
+    displayAlreadyInitializedError('OO_RUM', {} as InitConfiguration)
+    expect(displayErrorSpy).toHaveBeenCalledTimes(1)
+    expect(displayErrorSpy).toHaveBeenCalledWith('OO_RUM is already initialized.')
+  })
+
+  it('should not display an error if the "silentMultipleInit" option is used', () => {
+    const displayErrorSpy = spyOn(display, 'error')
+    displayAlreadyInitializedError('OO_RUM', { silentMultipleInit: true } as InitConfiguration)
+    expect(displayErrorSpy).not.toHaveBeenCalled()
+  })
+})

package/src/boot/init.spec.ts

@@ -0,0 +1,50 @@
+import { display } from '../tools/display'
+import { defineGlobal } from './init'
+
+describe('defineGlobal', () => {
+  it('adds new property to the global object', () => {
+    const myGlobal = {} as any
+    const value = 'my value'
+    defineGlobal(myGlobal, 'foo', value)
+    expect(myGlobal.foo).toBe(value)
+  })
+
+  it('overrides property if exists on the global object', () => {
+    const myGlobal = { foo: 'old value' }
+    const value = 'my value'
+    defineGlobal(myGlobal, 'foo', value)
+    expect(myGlobal.foo).toBe(value)
+  })
+
+  it('run the queued callbacks on the old value', () => {
+    const fn1 = jasmine.createSpy()
+    const fn2 = jasmine.createSpy()
+    const myGlobal: any = {
+      foo: {
+        q: [fn1, fn2],
+      },
+    }
+    const value = 'my value'
+    defineGlobal(myGlobal, 'foo', value)
+    expect(myGlobal.foo).toBe(value)
+    expect(fn1).toHaveBeenCalled()
+    expect(fn2).toHaveBeenCalled()
+  })
+
+  it('catches the errors thrown by the queued callbacks', () => {
+    const myError = 'Ooops!'
+    const onReady = () => {
+      // eslint-disable-next-line @typescript-eslint/only-throw-error
+      throw myError
+    }
+    const myGlobal: any = {
+      foo: {
+        q: [onReady],
+      },
+    }
+    const displaySpy = spyOn(display, 'error')
+
+    defineGlobal(myGlobal, 'foo', {})
+    expect(displaySpy).toHaveBeenCalledWith('onReady callback threw an error:', myError)
+  })
+})

package/src/browser/addEventListener.spec.ts

@@ -0,0 +1,141 @@
+// import type { Configuration } from '@openobserve/browser-core'
+// import { stubZoneJs } from '../../test'
+import type { Configuration } from '../domain/configuration'
+import { createNewEvent, mockZoneJs, registerCleanupTask } from '../../test'
+import type { MockZoneJs } from '../../test'
+import { noop } from '../tools/utils/functionUtils'
+import { addEventListener, DOM_EVENT } from './addEventListener'
+
+describe('addEventListener', () => {
+  let configuration: Configuration
+
+  describe('Zone.js support', () => {
+    let zoneJs: MockZoneJs
+
+    beforeEach(() => {
+      configuration = { allowUntrustedEvents: false } as Configuration
+      zoneJs = mockZoneJs()
+    })
+
+    it('uses the original addEventListener method instead of the method patched by Zone.js', () => {
+      const zoneJsPatchedAddEventListener = jasmine.createSpy()
+      const eventTarget = document.createElement('div')
+      zoneJs.replaceProperty(eventTarget, 'addEventListener', zoneJsPatchedAddEventListener)
+
+      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, noop)
+      expect(zoneJsPatchedAddEventListener).not.toHaveBeenCalled()
+    })
+
+    it('uses the original removeEventListener method instead of the method patched by Zone.js', () => {
+      const zoneJsPatchedRemoveEventListener = jasmine.createSpy()
+      const eventTarget = document.createElement('div')
+      zoneJs.replaceProperty(eventTarget, 'removeEventListener', zoneJsPatchedRemoveEventListener)
+
+      const { stop } = addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, noop)
+      stop()
+      expect(zoneJsPatchedRemoveEventListener).not.toHaveBeenCalled()
+    })
+  })
+
+  it('Use the EventTarget.prototype.addEventListener when the eventTarget is an instance of EventTarget', () => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalAddEventListener = EventTarget.prototype.addEventListener
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalRemoveEventListener = EventTarget.prototype.removeEventListener
+
+    EventTarget.prototype.addEventListener = jasmine.createSpy()
+    EventTarget.prototype.removeEventListener = jasmine.createSpy()
+
+    registerCleanupTask(() => {
+      EventTarget.prototype.addEventListener = originalAddEventListener
+      EventTarget.prototype.removeEventListener = originalRemoveEventListener
+    })
+
+    const htmlDivElement = document.createElement('div')
+    htmlDivElement.addEventListener = jasmine.createSpy()
+    htmlDivElement.removeEventListener = jasmine.createSpy()
+
+    const { stop } = addEventListener({ allowUntrustedEvents: false }, htmlDivElement, DOM_EVENT.CLICK, noop)
+
+    const event = createNewEvent(DOM_EVENT.CLICK)
+    htmlDivElement.dispatchEvent(event)
+    stop()
+
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(htmlDivElement.addEventListener).not.toHaveBeenCalled()
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(htmlDivElement.removeEventListener).not.toHaveBeenCalled()
+
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(EventTarget.prototype.addEventListener).toHaveBeenCalled()
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(EventTarget.prototype.removeEventListener).toHaveBeenCalled()
+  })
+
+  it('Use the addEventListener method when the eventTarget is not an instance of EventTarget', () => {
+    const listener = jasmine.createSpy()
+
+    const customEventTarget = {
+      addEventListener: jasmine.createSpy(),
+      removeEventListener: jasmine.createSpy(),
+    } as unknown as HTMLElement
+
+    const { stop } = addEventListener({ allowUntrustedEvents: false }, customEventTarget, 'change', listener)
+    stop()
+
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(customEventTarget.addEventListener).toHaveBeenCalled()
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(customEventTarget.removeEventListener).toHaveBeenCalled()
+  })
+
+  describe('Untrusted event', () => {
+    beforeEach(() => {
+      configuration = { allowUntrustedEvents: false } as Configuration
+    })
+
+    it('should be ignored if __ooIsTrusted is absent', () => {
+      const listener = jasmine.createSpy()
+      const eventTarget = document.createElement('div')
+      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
+
+      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: undefined })
+      eventTarget.dispatchEvent(event)
+      expect(listener).not.toHaveBeenCalled()
+    })
+
+    it('should be ignored if __ooIsTrusted is false', () => {
+      const listener = jasmine.createSpy()
+      const eventTarget = document.createElement('div')
+      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
+
+      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: false })
+      eventTarget.dispatchEvent(event)
+      expect(listener).not.toHaveBeenCalled()
+    })
+
+    it('should not be ignored if __ooIsTrusted is true', () => {
+      const listener = jasmine.createSpy()
+      const eventTarget = document.createElement('div')
+      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
+
+      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: true })
+      eventTarget.dispatchEvent(event)
+
+      expect(listener).toHaveBeenCalled()
+    })
+
+    it('should not be ignored if allowUntrustedEvents is true', () => {
+      const listener = jasmine.createSpy()
+      const eventTarget = document.createElement('div')
+      configuration = { allowUntrustedEvents: true } as Configuration
+
+      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
+
+      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: undefined })
+      eventTarget.dispatchEvent(event)
+
+      expect(listener).toHaveBeenCalled()
+    })
+  })
+})

package/src/browser/cookie.spec.ts

@@ -0,0 +1,53 @@
+import { mockCookies } from '../../test'
+import { getCurrentSite, resetGetCurrentSite } from './cookie'
+
+describe('cookie', () => {
+  describe('getCurrentSite', () => {
+    beforeEach(() => {
+      resetGetCurrentSite()
+    })
+
+    it('returns the eTLD+1 for example.com', () => {
+      mockCookies()
+      expect(getCurrentSite('example.com')).toBe('example.com')
+    })
+
+    it('returns the eTLD+1 for example.co.uk', () => {
+      mockCookies({
+        filter: (cookie) => cookie.domain !== '.co.uk',
+      })
+      expect(getCurrentSite('example.co.uk')).toBe('example.co.uk')
+    })
+
+    it('returns the eTLD+1 for foo.bar.baz.example.com', () => {
+      mockCookies()
+      expect(getCurrentSite('foo.bar.baz.example.com')).toBe('example.com')
+    })
+
+    it('does not left any cookies', () => {
+      const { getCookies } = mockCookies()
+      expect(getCurrentSite('example.com')).toBe('example.com')
+      expect(getCookies()).toEqual([])
+    })
+
+    it('falls back to the referrer when the hostname is empty', () => {
+      mockCookies()
+      expect(getCurrentSite('', 'https://example.com')).toBe('example.com')
+    })
+
+    it('returns undefined when the referrer is empty', () => {
+      mockCookies()
+      expect(getCurrentSite('', '')).toBeUndefined()
+    })
+
+    it('caches the result', () => {
+      const { setter } = mockCookies()
+
+      expect(getCurrentSite('example.com')).toBe('example.com')
+      expect(setter).toHaveBeenCalledTimes(2)
+
+      expect(getCurrentSite('example.com')).toBe('example.com')
+      expect(setter).toHaveBeenCalledTimes(2)
+    })
+  })
+})