@openobserve/browser-core 0.2.11 → 0.2.12-beta.1

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "@openobserve/browser-core",
-  "version": "0.2.11",
+  "version": "0.2.12-beta.1",
   "license": "Apache-2.0",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "types": "cjs/index.d.ts",
   "sideEffects": false,
   "scripts": {
-    "build": "run-p build:cjs build:esm",
-    "build:cjs": "rm -rf cjs && tsc -p tsconfig.cjs.json && yarn replace-build-env cjs",
-    "build:esm": "rm -rf esm && tsc -p tsconfig.esm.json && yarn replace-build-env esm",
-    "replace-build-env": "node ../../scripts/build/replace-build-env.js"
+    "build": "node ../../scripts/build/build-package.ts --modules"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/openobserve/browser-sdk.git",
     "directory": "packages/core"
   },
+  "devDependencies": {
+    "@types/pako": "2.0.4",
+    "pako": "2.1.0"
+  },
   "volta": {
     "extends": "../../package.json"
   },

package/src/boot/displayAlreadyInitializedError.ts

@@ -0,0 +1,8 @@
+import type { InitConfiguration } from '../domain/configuration'
+import { display } from '../tools/display'
+
+export function displayAlreadyInitializedError(sdkName: 'DD_RUM' | 'DD_LOGS', initConfiguration: InitConfiguration) {
+  if (!initConfiguration.silentMultipleInit) {
+    display.error(`${sdkName} is already initialized.`)
+  }
+}

package/src/boot/init.ts

@@ -1,24 +1,35 @@
 import { catchUserErrors } from '../tools/catchUserErrors'
 import { setDebugMode } from '../tools/monitor'
-import { assign } from '../tools/utils/polyfills'
+import { display } from '../tools/display'
 
 // replaced at build time
 declare const __BUILD_ENV__SDK_VERSION__: string
 
-export function makePublicApi<T>(stub: T): T & { onReady(callback: () => void): void; version: string } {
-  const publicApi = assign(
-    {
-      version: __BUILD_ENV__SDK_VERSION__,
+export interface PublicApi {
+  /**
+   * Version of the Logs browser SDK
+   */
+  version: string
 
-      // 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.
-      onReady(callback: () => void) {
-        callback()
-      },
+  /**
+   * For CDN async setup: Early RUM API calls must be wrapped in the `window.DD_RUM.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.
+   *
+   * See [CDN async setup](https://docs.datadoghq.com/real_user_monitoring/browser/#cdn-async) for further information.
+   */
+  onReady: (callback: () => void) => void
+}
+
+export function makePublicApi<T extends PublicApi>(stub: Omit<T, keyof PublicApi>): T {
+  const publicApi = {
+    version: __BUILD_ENV__SDK_VERSION__,
+    // 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.
+    onReady(callback: () => void) {
+      callback()
     },
-    stub
-  )
+    ...stub,
+  }
 
   // Add a "hidden" property to set debug mode. We define it that way to hide it
   // as much as possible but of course it's not a real protection.
@@ -29,11 +40,14 @@ export function makePublicApi<T>(stub: T): T & { onReady(callback: () => void):
     enumerable: false,
   })
 
-  return publicApi
+  return publicApi as T
 }
 
 export function defineGlobal<Global, Name extends keyof Global>(global: Global, name: Name, api: Global[Name]) {
-  const existingGlobalVariable = global[name] as { q?: Array<() => void> } | undefined
+  const existingGlobalVariable = global[name] as { q?: Array<() => void>; version?: string } | undefined
+  if (existingGlobalVariable && !existingGlobalVariable.q && existingGlobalVariable.version) {
+    display.warn('SDK is loaded more than once. This is unsupported and might have unexpected behavior.')
+  }
   global[name] = api
   if (existingGlobalVariable && existingGlobalVariable.q) {
     existingGlobalVariable.q.forEach((fn) => catchUserErrors(fn, 'onReady callback threw an error:')())

package/src/browser/addEventListener.ts

@@ -1,7 +1,8 @@
 import { monitor } from '../tools/monitor'
 import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
-import type { Configuration } from '../domain/configuration'
-import type { VisualViewport, VisualViewportEventMap } from './types'
+import type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'
+
+export type TrustableEvent<E extends Event = Event> = E & { __ddIsTrusted?: boolean }
 
 export const enum DOM_EVENT {
   BEFORE_UNLOAD = 'beforeunload',
@@ -37,6 +38,7 @@ export const enum DOM_EVENT {
   PAUSE = 'pause',
   SECURITY_POLICY_VIOLATION = 'securitypolicyviolation',
   SELECTION_CHANGE = 'selectionchange',
+  STORAGE = 'storage',
 }
 
 interface AddEventListenerOptions {
@@ -54,23 +56,25 @@ type EventMapFor<T> = T extends Window
       visibilitychange: Event
     }
   : T extends Document
-  ? DocumentEventMap
-  : T extends HTMLElement
-  ? HTMLElementEventMap
-  : T extends VisualViewport
-  ? VisualViewportEventMap
-  : T extends ShadowRoot
-  ? // ShadowRootEventMap is not yet defined in our supported TS version. Instead, use
-    // GlobalEventHandlersEventMap which is more than enough as we only need to listen for events bubbling
-    // through the ShadowRoot like "change" or "input"
-    GlobalEventHandlersEventMap
-  : T extends XMLHttpRequest
-  ? XMLHttpRequestEventMap
-  : T extends Performance
-  ? PerformanceEventMap
-  : T extends Worker
-  ? WorkerEventMap
-  : Record<never, never>
+    ? DocumentEventMap
+    : T extends HTMLElement
+      ? HTMLElementEventMap
+      : T extends VisualViewport
+        ? VisualViewportEventMap
+        : T extends ShadowRoot
+          ? // ShadowRootEventMap is not yet defined in our supported TS version. Instead, use
+            // GlobalEventHandlersEventMap which is more than enough as we only need to listen for events bubbling
+            // through the ShadowRoot like "change" or "input"
+            GlobalEventHandlersEventMap
+          : T extends XMLHttpRequest
+            ? XMLHttpRequestEventMap
+            : T extends Performance
+              ? PerformanceEventMap
+              : T extends Worker
+                ? WorkerEventMap
+                : T extends CookieStore
+                  ? CookieStoreEventMap
+                  : Record<never, never>
 
 /**
  * Add an event listener to an event target object (Window, Element, mock object...).  This provides
@@ -83,10 +87,10 @@ type EventMapFor<T> = T extends Window
  * * returns a `stop` function to remove the listener
  */
 export function addEventListener<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
-  configuration: Configuration,
+  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventName: EventName,
-  listener: (event: EventMapFor<Target>[EventName]) => void,
+  listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
   options?: AddEventListenerOptions
 ) {
   return addEventListeners(configuration, eventTarget, [eventName], listener, options)
@@ -105,29 +109,34 @@ export function addEventListener<Target extends EventTarget, EventName extends k
  * * with `once: true`, the listener will be called at most once, even if different events are listened
  */
 export function addEventListeners<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
-  _: Configuration,
+  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventNames: EventName[],
-  listener: (event: EventMapFor<Target>[EventName]) => void,
+  listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
   { once, capture, passive }: AddEventListenerOptions = {}
 ) {
-  const wrappedListener = monitor(
-    once
-      ? (event: Event) => {
-          stop()
-          listener(event as EventMapFor<Target>[EventName])
-        }
-      : (listener as (event: Event) => void)
-  )
+  const listenerWithMonitor = monitor((event: TrustableEvent) => {
+    if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {
+      return
+    }
+    if (once) {
+      stop()
+    }
+    listener(event as unknown as EventMapFor<Target>[EventName] & { type: EventName })
+  })
 
   const options = passive ? { capture, passive } : capture
 
-  const add = getZoneJsOriginalValue(eventTarget, 'addEventListener')
-  eventNames.forEach((eventName) => add.call(eventTarget, eventName, wrappedListener, options))
+  // Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)
+  const listenerTarget =
+    window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget
+
+  const add = getZoneJsOriginalValue(listenerTarget, 'addEventListener')
+  eventNames.forEach((eventName) => add.call(eventTarget, eventName, listenerWithMonitor, options))
 
   function stop() {
-    const remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener')
-    eventNames.forEach((eventName) => remove.call(eventTarget, eventName, wrappedListener, options))
+    const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener')
+    eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options))
   }
 
   return {

package/src/browser/{types.ts → browser.types.ts}

@@ -38,3 +38,45 @@ export interface VisualViewport extends EventTarget {
     options?: boolean | EventListenerOptions
   ): void
 }
+
+export interface WeakRef<T extends object> {
+  readonly [Symbol.toStringTag]: 'WeakRef'
+
+  deref(): T | undefined
+}
+
+export interface WeakRefConstructor {
+  readonly prototype: WeakRef<any>
+
+  new <T extends object>(target: T): WeakRef<T>
+}
+
+export interface CookieStore extends EventTarget {
+  get(name: string): Promise<unknown>
+  getAll(name?: string): Promise<
+    Array<{
+      name: string
+      value: string
+      domain?: string
+      path?: string
+      expires?: number
+      secure?: boolean
+      sameSite?: 'strict' | 'lax' | 'none'
+      partitioned?: boolean
+    }>
+  >
+}
+
+export interface CookieStoreEventMap {
+  change: CookieChangeEvent
+}
+
+export interface CookieChangeItem {
+  name: string
+  value: string | undefined
+}
+
+export type CookieChangeEvent = Event & {
+  changed: CookieChangeItem[]
+  deleted: CookieChangeItem[]
+}

package/src/browser/cookie.ts

@@ -1,27 +1,65 @@
 import { display } from '../tools/display'
 import { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
-import { findCommaSeparatedValue, generateUUID } from '../tools/utils/stringUtils'
+import {
+  findAllCommaSeparatedValues,
+  findCommaSeparatedValue,
+  findCommaSeparatedValues,
+  generateUUID,
+} from '../tools/utils/stringUtils'
+import { buildUrl } from '../tools/utils/urlPolyfill'
 
 export interface CookieOptions {
   secure?: boolean
   crossSite?: boolean
+  partitioned?: boolean
   domain?: string
 }
 
-export function setCookie(name: string, value: string, expireDelay: number, options?: CookieOptions) {
+export function setCookie(name: string, value: string, expireDelay: number = 0, options?: CookieOptions) {
   const date = new Date()
   date.setTime(date.getTime() + expireDelay)
   const expires = `expires=${date.toUTCString()}`
   const sameSite = options && options.crossSite ? 'none' : 'strict'
   const domain = options && options.domain ? `;domain=${options.domain}` : ''
   const secure = options && options.secure ? ';secure' : ''
-  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}`
+  const partitioned = options && options.partitioned ? ';partitioned' : ''
+  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`
 }
 
+/**
+ * Returns the value of the cookie with the given name
+ * If there are multiple cookies with the same name, returns the first one
+ */
 export function getCookie(name: string) {
   return findCommaSeparatedValue(document.cookie, name)
 }
 
+/**
+ * Returns all the values of the cookies with the given name
+ */
+export function getCookies(name: string): string[] {
+  return findAllCommaSeparatedValues(document.cookie).get(name) || []
+}
+
+let initCookieParsed: Map<string, string> | undefined
+
+/**
+ * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)
+ * to avoid accessing document.cookie multiple times.
+ *
+ * ⚠️ If there are multiple cookies with the same name, returns the LAST one (unlike `getCookie()`)
+ */
+export function getInitCookie(name: string) {
+  if (!initCookieParsed) {
+    initCookieParsed = findCommaSeparatedValues(document.cookie)
+  }
+  return initCookieParsed.get(name)
+}
+
+export function resetInitCookies() {
+  initCookieParsed = undefined
+}
+
 export function deleteCookie(name: string, options?: CookieOptions) {
   setCookie(name, '', 0, options)
 }
@@ -51,21 +89,37 @@ export function areCookiesAuthorized(options: CookieOptions): boolean {
  * https://web.dev/same-site-same-origin/#site
  */
 let getCurrentSiteCache: string | undefined
-export function getCurrentSite() {
+export function getCurrentSite(hostname = location.hostname, referrer = document.referrer): string | undefined {
   if (getCurrentSiteCache === undefined) {
-    // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
-    // the test cookie lifetime
-    const testCookieName = `oo_site_test_${generateUUID()}`
-    const testCookieValue = 'test'
+    const defaultHostName = getCookieDefaultHostName(hostname, referrer)
+    if (defaultHostName) {
+      // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
+      // the test cookie lifetime
+      const testCookieName = `oo_site_test_${generateUUID()}`
+      const testCookieValue = 'test'
 
-    const domainLevels = window.location.hostname.split('.')
-    let candidateDomain = domainLevels.pop()!
-    while (domainLevels.length && !getCookie(testCookieName)) {
-      candidateDomain = `${domainLevels.pop()!}.${candidateDomain}`
-      setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain })
+      const domainLevels = defaultHostName.split('.')
+      let candidateDomain = domainLevels.pop()!
+      while (domainLevels.length && !getCookie(testCookieName)) {
+        candidateDomain = `${domainLevels.pop()!}.${candidateDomain}`
+        setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain })
+      }
+      deleteCookie(testCookieName, { domain: candidateDomain })
+      getCurrentSiteCache = candidateDomain
     }
-    deleteCookie(testCookieName, { domain: candidateDomain })
-    getCurrentSiteCache = candidateDomain
   }
+
   return getCurrentSiteCache
 }
+
+function getCookieDefaultHostName(hostname: string, referrer: string) {
+  try {
+    return hostname || buildUrl(referrer).hostname
+  } catch {
+    // Ignore
+  }
+}
+
+export function resetGetCurrentSite() {
+  getCurrentSiteCache = undefined
+}

package/src/browser/fetchObservable.ts

@@ -1,9 +1,14 @@
+import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
 import { instrumentMethod } from '../tools/instrumentMethod'
-import { callMonitored, monitor } from '../tools/monitor'
+import { monitorError } from '../tools/monitor'
 import { Observable } from '../tools/observable'
 import type { ClocksState } from '../tools/utils/timeUtils'
 import { clocksNow } from '../tools/utils/timeUtils'
 import { normalizeUrl } from '../tools/utils/urlPolyfill'
+import type { GlobalObject } from '../tools/globalObject'
+import { globalObject } from '../tools/globalObject'
+import { readBytesFromStream } from '../tools/readBytesFromStream'
+import { tryToClone } from '../tools/utils/responseUtils'
 
 interface FetchContextBase {
   method: string
@@ -11,6 +16,7 @@ interface FetchContextBase {
   input: unknown
   init?: RequestInit
   url: string
+  handlingStack?: string
 }
 
 export interface FetchStartContext extends FetchContextBase {
@@ -21,6 +27,7 @@ export interface FetchResolveContext extends FetchContextBase {
   state: 'resolve'
   status: number
   response?: Response
+  responseBody?: string
   responseType?: string
   isAborted: boolean
   error?: Error
@@ -28,48 +35,64 @@ export interface FetchResolveContext extends FetchContextBase {
 
 export type FetchContext = FetchStartContext | FetchResolveContext
 
+type ResponseBodyActionGetter = (context: FetchResolveContext) => ResponseBodyAction
+
+/**
+ * Action to take with the response body of a fetch request.
+ * Values are ordered by priority: higher values take precedence when multiple actions are requested.
+ */
+export const enum ResponseBodyAction {
+  IGNORE = 0,
+  // TODO(next-major): Remove the "WAIT" action when `trackEarlyRequests` is removed, as the
+  // duration of fetch requests will always come from PerformanceResourceTiming
+  WAIT = 1,
+  COLLECT = 2,
+}
+
 let fetchObservable: Observable<FetchContext> | undefined
+const responseBodyActionGetters: ResponseBodyActionGetter[] = []
 
-export function initFetchObservable() {
+export function initFetchObservable({ responseBodyAction }: { responseBodyAction?: ResponseBodyActionGetter } = {}) {
+  if (responseBodyAction) {
+    responseBodyActionGetters.push(responseBodyAction)
+  }
   if (!fetchObservable) {
     fetchObservable = createFetchObservable()
   }
   return fetchObservable
 }
 
+export function resetFetchObservable() {
+  fetchObservable = undefined
+  responseBodyActionGetters.length = 0
+}
+
 function createFetchObservable() {
-  const observable = new Observable<FetchContext>(() => {
-    if (!window.fetch) {
+  return new Observable<FetchContext>((observable) => {
+    if (!globalObject.fetch) {
       return
     }
 
-    const { stop } = instrumentMethod(
-      window,
-      'fetch',
-      (originalFetch) =>
-        function (input, init) {
-          let responsePromise: Promise<Response>
-
-          const context = callMonitored(beforeSend, null, [observable, input, init])
-          if (context) {
-            responsePromise = originalFetch.call(this, context.input as RequestInfo, context.init)
-            callMonitored(afterSend, null, [observable, responsePromise, context])
-          } else {
-            responsePromise = originalFetch.call(this, input, init)
-          }
-
-          return responsePromise
-        }
-    )
+    const { stop } = instrumentMethod(globalObject, 'fetch', (call) => beforeSend(call, observable), {
+      computeHandlingStack: true,
+    })
 
     return stop
   })
-
-  return observable
 }
 
-function beforeSend(observable: Observable<FetchContext>, input: unknown, init?: RequestInit) {
-  const method = (init && init.method) || (input instanceof Request && input.method) || 'GET'
+function beforeSend(
+  { parameters, onPostCall, handlingStack }: InstrumentedMethodCall<GlobalObject, 'fetch'>,
+  observable: Observable<FetchContext>
+) {
+  const [input, init] = parameters
+  let methodFromParams = init && init.method
+
+  if (methodFromParams === undefined && input instanceof Request) {
+    methodFromParams = input.method
+  }
+
+  const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET'
   const url = input instanceof Request ? input.url : normalizeUrl(String(input))
   const startClocks = clocksNow()
 
@@ -80,33 +103,65 @@ function beforeSend(observable: Observable<FetchContext>, input: unknown, init?:
     method,
     startClocks,
     url,
+    handlingStack,
   }
 
   observable.notify(context)
 
-  return context
+  // Those properties can be changed by observable subscribers
+  parameters[0] = context.input as RequestInfo | URL
+  parameters[1] = context.init
+
+  onPostCall((responsePromise) => {
+    afterSend(observable, responsePromise, context).catch(monitorError)
+  })
 }
 
-function afterSend(
+async function afterSend(
   observable: Observable<FetchContext>,
   responsePromise: Promise<Response>,
   startContext: FetchStartContext
 ) {
-  const reportFetch = (response: Response | Error) => {
-    const context = startContext as unknown as FetchResolveContext
-    context.state = 'resolve'
-    if ('stack' in response || response instanceof Error) {
-      context.status = 0
-      context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR
-      context.error = response
-    } else if ('status' in response) {
-      context.response = response
-      context.responseType = response.type
-      context.status = response.status
-      context.isAborted = false
-    }
+  const context = startContext as unknown as FetchResolveContext
+  context.state = 'resolve'
+
+  let response: Response
+
+  try {
+    response = await responsePromise
+  } catch (error) {
+    context.status = 0
+    context.isAborted =
+      context.init?.signal?.aborted || (error instanceof DOMException && error.code === DOMException.ABORT_ERR)
+    context.error = error as Error
     observable.notify(context)
+    return
   }
 
-  responsePromise.then(monitor(reportFetch), monitor(reportFetch))
+  context.response = response
+  context.status = response.status
+  context.responseType = response.type
+  context.isAborted = false
+
+  const responseBodyCondition = responseBodyActionGetters.reduce(
+    (action, getter) => Math.max(action, getter(context)),
+    ResponseBodyAction.IGNORE
+  ) as ResponseBodyAction
+
+  if (responseBodyCondition !== ResponseBodyAction.IGNORE) {
+    const clonedResponse = tryToClone(response)
+    if (clonedResponse && clonedResponse.body) {
+      try {
+        const bytes = await readBytesFromStream(clonedResponse.body, {
+          collectStreamBody: responseBodyCondition === ResponseBodyAction.COLLECT,
+        })
+        context.responseBody = bytes && new TextDecoder().decode(bytes)
+      } catch {
+        // Ignore errors when reading the response body (e.g., stream aborted, network errors)
+        // This is not critical and should not be reported as an SDK error
+      }
+    }
+  }
+
+  observable.notify(context)
 }

package/src/browser/{pageExitObservable.ts → pageMayExitObservable.ts}

@@ -1,7 +1,5 @@
-import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../tools/experimentalFeatures'
 import { Observable } from '../tools/observable'
-import { objectValues, includes } from '../tools/utils/polyfills'
-import { noop } from '../tools/utils/functionUtils'
+import { objectValues } from '../tools/utils/polyfills'
 import type { Configuration } from '../domain/configuration'
 import { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener'
 
@@ -14,24 +12,18 @@ export const PageExitReason = {
 
 export type PageExitReason = (typeof PageExitReason)[keyof typeof PageExitReason]
 
-export interface PageExitEvent {
+export interface PageMayExitEvent {
   reason: PageExitReason
 }
 
-export function createPageExitObservable(configuration: Configuration): Observable<PageExitEvent> {
-  const observable = new Observable<PageExitEvent>(() => {
-    const pagehideEnabled = isExperimentalFeatureEnabled(ExperimentalFeature.PAGEHIDE)
+export function createPageMayExitObservable(configuration: Configuration): Observable<PageMayExitEvent> {
+  return new Observable<PageMayExitEvent>((observable) => {
     const { stop: stopListeners } = addEventListeners(
       configuration,
       window,
-      [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE, DOM_EVENT.PAGE_HIDE],
+      [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],
       (event) => {
-        if (event.type === DOM_EVENT.PAGE_HIDE && pagehideEnabled) {
-          /**
-           * Only event that detect page unload events while being compatible with the back/forward cache (bfcache)
-           */
-          observable.notify({ reason: PageExitReason.PAGEHIDE })
-        } else if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
+        if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
           /**
            * Only event that guarantee to fire on mobile devices when the page transitions to background state
            * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
@@ -48,22 +40,17 @@ export function createPageExitObservable(configuration: Configuration): Observab
       { capture: true }
     )
 
-    let stopBeforeUnloadListener = noop
-    if (!pagehideEnabled) {
-      stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, () => {
-        observable.notify({ reason: PageExitReason.UNLOADING })
-      }).stop
-    }
+    const stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, () => {
+      observable.notify({ reason: PageExitReason.UNLOADING })
+    }).stop
 
     return () => {
       stopListeners()
       stopBeforeUnloadListener()
     }
   })
-
-  return observable
 }
 
-export function isPageExitReason(reason: string | undefined): reason is PageExitReason {
-  return includes(objectValues(PageExitReason), reason)
+export function isPageExitReason(reason: string): reason is PageExitReason {
+  return objectValues(PageExitReason).includes(reason as PageExitReason)
 }