@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/src/browser/cookie.ts

@@ -1,5 +1,4 @@
-import { display } from '../tools/display'
-import { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
+import { ONE_SECOND } from '@openobserve/js-core/time'
 import {
   findAllCommaSeparatedValues,
   findCommaSeparatedValue,
@@ -7,6 +6,7 @@ import {
   generateUUID,
 } from '../tools/utils/stringUtils'
 import { buildUrl } from '../tools/utils/urlPolyfill'
+import { globalObject } from '../tools/globalObject'
 
 export interface CookieOptions {
   secure?: boolean
@@ -19,10 +19,10 @@ export function setCookie(name: string, value: string, expireDelay: number = 0,
   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' : ''
-  const partitioned = options && options.partitioned ? ';partitioned' : ''
+  const sameSite = options?.crossSite ? 'none' : 'strict'
+  const domain = options?.domain ? `;domain=${options.domain}` : ''
+  const secure = options?.secure ? ';secure' : ''
+  const partitioned = options?.partitioned ? ';partitioned' : ''
   document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`
 }
 
@@ -31,7 +31,13 @@ export function setCookie(name: string, value: string, expireDelay: number = 0,
  * If there are multiple cookies with the same name, returns the first one
  */
 export function getCookie(name: string) {
-  return findCommaSeparatedValue(document.cookie, name)
+  const value = findCommaSeparatedValue(document.cookie, name)
+
+  if (value === '') {
+    return
+  }
+
+  return value
 }
 
 /**
@@ -64,32 +70,20 @@ export function deleteCookie(name: string, options?: CookieOptions) {
   setCookie(name, '', 0, options)
 }
 
-export function areCookiesAuthorized(options: CookieOptions): boolean {
-  if (document.cookie === undefined || document.cookie === null) {
-    return false
-  }
-  try {
-    // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
-    // the test cookie lifetime
-    const testCookieName = `oo_cookie_test_${generateUUID()}`
-    const testCookieValue = 'test'
-    setCookie(testCookieName, testCookieValue, ONE_MINUTE, options)
-    const isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue
-    deleteCookie(testCookieName, options)
-    return isCookieCorrectlySet
-  } catch (error) {
-    display.error(error)
-    return false
-  }
-}
-
 /**
  * No API to retrieve it, number of levels for subdomain and suffix are unknown
  * strategy: find the minimal domain on which cookies are allowed to be set
  * https://web.dev/same-site-same-origin/#site
  */
 let getCurrentSiteCache: string | undefined
-export function getCurrentSite(hostname = location.hostname, referrer = document.referrer): string | undefined {
+export function getCurrentSite(
+  hostname = globalObject.location?.hostname ?? '',
+  referrer = typeof document !== 'undefined' ? document.referrer : ''
+): string | undefined {
+  // Cookie probing requires document.cookie, which is not available in Web Workers or Node.js
+  if (typeof document === 'undefined') {
+    return undefined
+  }
   if (getCurrentSiteCache === undefined) {
     const defaultHostName = getCookieDefaultHostName(hostname, referrer)
     if (defaultHostName) {

package/src/browser/cookieAccess.ts

@@ -0,0 +1,150 @@
+import { ONE_MINUTE, ONE_SECOND, dateNow } from '@openobserve/js-core/time'
+import { setInterval, clearInterval } from '../tools/timer'
+import { Observable } from '../tools/observable'
+import { mockable } from '../tools/mockable'
+import { display } from '../tools/display'
+import { generateUUID } from '../tools/utils/stringUtils'
+import { addTelemetryDebug } from '../domain/telemetry'
+import { globalObject } from '../tools/globalObject'
+import { addEventListener, DOM_EVENT, isEventSupported } from './addEventListener'
+import { getCookies, setCookie } from './cookie'
+import type { CookieOptions } from './cookie'
+
+export interface CookieAccess {
+  getAll(): Promise<string[]>
+  getAllAndSet(cb: (value: string[]) => { value: string; expireDelay: number }): Promise<void>
+  observable: Observable<void>
+}
+
+export type CookieAccessFactory = (cookieName: string, cookieOptions: CookieOptions) => CookieAccess
+
+export async function areCookiesAuthorized(
+  createAccess: CookieAccessFactory,
+  cookieOptions: CookieOptions
+): Promise<boolean> {
+  // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
+  // the test cookie lifetime
+  const testCookieName = `oo_cookie_test_${generateUUID()}`
+  const testCookieValue = 'test'
+  const access = createAccess(testCookieName, cookieOptions)
+  try {
+    await access.getAllAndSet(() => ({ value: testCookieValue, expireDelay: ONE_MINUTE }))
+    const values = await access.getAll()
+    return values.includes(testCookieValue)
+  } catch (error) {
+    display.error(error)
+    return false
+  } finally {
+    try {
+      await access.getAllAndSet(() => ({ value: '', expireDelay: 0 }))
+    } catch {
+      // Best-effort cleanup
+    }
+  }
+}
+
+export function createCookieStoreAccess(cookieName: string, cookieOptions: CookieOptions): CookieAccess {
+  const cookieStore = mockable(globalObject.cookieStore)!
+  const observable = new Observable<void>(() => {
+    const listener = addEventListener(cookieStore, DOM_EVENT.CHANGE, (event) => {
+      // Based on our experimentation, we're assuming that entries for the same cookie cannot be in both the 'changed' and 'deleted' arrays.
+      // However, due to ambiguity in the specification, we asked for clarification: https://github.com/WICG/cookie-store/issues/226
+      const changeEvent =
+        event.changed.some((event) => event.name === cookieName) ||
+        event.deleted.some((event) => event.name === cookieName)
+      if (changeEvent) {
+        observable.notify()
+      }
+    })
+    return listener.stop
+  })
+
+  return {
+    async getAll() {
+      const items = await cookieStore.getAll(cookieName)
+      return items.map((item) => item.value)
+    },
+
+    async getAllAndSet(cb: (value: string[]) => { value: string; expireDelay: number }) {
+      const items = await cookieStore.getAll(cookieName)
+
+      const currentValues = items.map((item) => item.value)
+      const { value, expireDelay } = cb(currentValues)
+
+      try {
+        await cookieStore.set({
+          name: cookieName,
+          value,
+          expires: dateNow() + expireDelay,
+          path: '/',
+          sameSite: cookieOptions.crossSite ? 'none' : 'strict',
+          domain: cookieOptions.domain,
+          secure: cookieOptions.secure,
+          partitioned: cookieOptions.partitioned,
+        })
+      } catch (error) {
+        const documentCookies = getCookies(cookieName)
+        // monitor-until: 2026-07-01
+        addTelemetryDebug('Failed to set cookie using Cookie Store API', {
+          'error.message': (error as Error).message,
+          newValue: value,
+          cookieOptions: {
+            ...cookieOptions,
+          },
+          cookies: items.map((item) => ({
+            ...item,
+          })),
+          cookieCount: items.length,
+          documentCookies,
+        })
+      }
+    },
+
+    observable,
+  }
+}
+
+export const WATCH_COOKIE_INTERVAL_DELAY = ONE_SECOND
+export function createDocumentCookieAccess(cookieName: string, cookieOptions: CookieOptions): CookieAccess {
+  let previousCookieValues = getCookies(cookieName)
+
+  const observable = new Observable<void>(() => {
+    const watchCookieIntervalId = setInterval(() => {
+      const cookieValues = getCookies(cookieName)
+      notifyCookieValueIfChanged(cookieValues)
+    }, WATCH_COOKIE_INTERVAL_DELAY)
+
+    return () => {
+      clearInterval(watchCookieIntervalId)
+    }
+  })
+
+  function notifyCookieValueIfChanged(cookieValues: string[]) {
+    if (String(cookieValues) !== String(previousCookieValues)) {
+      previousCookieValues = cookieValues
+      observable.notify()
+    }
+  }
+
+  return {
+    getAll() {
+      return Promise.resolve(getCookies(cookieName))
+    },
+
+    async getAllAndSet(cb: (value: string[]) => { value: string; expireDelay: number }) {
+      const currentValue = getCookies(cookieName)
+      const { value, expireDelay } = cb(currentValue)
+      setCookie(cookieName, value, expireDelay, cookieOptions)
+      await Promise.resolve()
+      notifyCookieValueIfChanged([value])
+    },
+
+    observable,
+  }
+}
+
+// Salesforce LWS does not support the change event of CookieStore objects. https://developer.salesforce.com/tools/lws-distortion-viewer
+export function isCookieStoreSupported(): boolean {
+  const cookieStore = mockable(globalObject.cookieStore)
+  return Boolean(cookieStore && isEventSupported(cookieStore, DOM_EVENT.CHANGE))
+}

package/src/browser/fetch.ts

@@ -0,0 +1,14 @@
+import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
+import { globalObject } from '../tools/globalObject'
+
+/**
+ * Make a fetch request using the native implementation, bypassing Zone.js patching.
+ * This prevents unnecessary Angular change detection cycles.
+ *
+ * @param input - The resource to fetch (URL or Request object)
+ * @param init - Optional fetch options
+ * @returns A Promise that resolves to the Response
+ */
+export function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+  return getZoneJsOriginalValue(globalObject, 'fetch')(input, init)
+}

package/src/browser/fetchObservable.ts

@@ -1,9 +1,9 @@
+import type { ClocksState } from '@openobserve/js-core/time'
+import { clocksNow } from '@openobserve/js-core/time'
 import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
 import { instrumentMethod } from '../tools/instrumentMethod'
 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'
@@ -17,6 +17,7 @@ interface FetchContextBase {
   init?: RequestInit
   url: string
   handlingStack?: string
+  isAbortedOnStart: boolean
 }
 
 export interface FetchStartContext extends FetchContextBase {
@@ -43,10 +44,7 @@ type ResponseBodyActionGetter = (context: FetchResolveContext) => ResponseBodyAc
  */
 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,
+  COLLECT = 1,
 }
 
 let fetchObservable: Observable<FetchContext> | undefined
@@ -69,6 +67,7 @@ export function resetFetchObservable() {
 
 function createFetchObservable() {
   return new Observable<FetchContext>((observable) => {
+    // eslint-disable-next-line local-rules/disallow-zone-js-patched-values
     if (!globalObject.fetch) {
       return
     }
@@ -86,7 +85,7 @@ function beforeSend(
   observable: Observable<FetchContext>
 ) {
   const [input, init] = parameters
-  let methodFromParams = init && init.method
+  let methodFromParams = init?.method
 
   if (methodFromParams === undefined && input instanceof Request) {
     methodFromParams = input.method
@@ -104,6 +103,7 @@ function beforeSend(
     startClocks,
     url,
     handlingStack,
+    isAbortedOnStart: (input instanceof Request && input.signal?.aborted) || init?.signal?.aborted || false,
   }
 
   observable.notify(context)
@@ -123,18 +123,20 @@ async function afterSend(
   startContext: FetchStartContext
 ) {
   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)
+    observable.notify({
+      ...context,
+      state: 'resolve',
+      status: 0,
+      isAborted:
+        context.init?.signal?.aborted || (error instanceof DOMException && error.code === DOMException.ABORT_ERR),
+      error: error as Error,
+    })
     return
   }
 
@@ -143,19 +145,17 @@ async function afterSend(
   context.responseType = response.type
   context.isAborted = false
 
-  const responseBodyCondition = responseBodyActionGetters.reduce(
+  const responseBodyCondition: ResponseBodyAction = responseBodyActionGetters.reduce<number>(
     (action, getter) => Math.max(action, getter(context)),
     ResponseBodyAction.IGNORE
-  ) as ResponseBodyAction
+  )
 
-  if (responseBodyCondition !== ResponseBodyAction.IGNORE) {
+  if (responseBodyCondition === ResponseBodyAction.COLLECT) {
     const clonedResponse = tryToClone(response)
-    if (clonedResponse && clonedResponse.body) {
+    if (clonedResponse?.body) {
       try {
-        const bytes = await readBytesFromStream(clonedResponse.body, {
-          collectStreamBody: responseBodyCondition === ResponseBodyAction.COLLECT,
-        })
-        context.responseBody = bytes && new TextDecoder().decode(bytes)
+        const bytes = await readBytesFromStream(clonedResponse.body)
+        context.responseBody = 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
@@ -163,5 +163,5 @@ async function afterSend(
     }
   }
 
-  observable.notify(context)
+  observable.notify({ ...context, state: 'resolve' })
 }

package/src/browser/pageMayExitObservable.ts

@@ -1,6 +1,6 @@
 import { Observable } from '../tools/observable'
 import { objectValues } from '../tools/utils/polyfills'
-import type { Configuration } from '../domain/configuration'
+import { isWorkerEnvironment } from '../tools/globalObject'
 import { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener'
 
 export const PageExitReason = {
@@ -16,10 +16,13 @@ export interface PageMayExitEvent {
   reason: PageExitReason
 }
 
-export function createPageMayExitObservable(configuration: Configuration): Observable<PageMayExitEvent> {
+export function createPageMayExitObservable(): Observable<PageMayExitEvent> {
   return new Observable<PageMayExitEvent>((observable) => {
+    if (isWorkerEnvironment) {
+      // Page exit is not observable in worker environments (no window/document events)
+      return
+    }
     const { stop: stopListeners } = addEventListeners(
-      configuration,
       window,
       [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],
       (event) => {
@@ -40,7 +43,7 @@ export function createPageMayExitObservable(configuration: Configuration): Obser
       { capture: true }
     )
 
-    const stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, () => {
+    const stopBeforeUnloadListener = addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, () => {
       observable.notify({ reason: PageExitReason.UNLOADING })
     }).stop
 

package/src/browser/runOnReadyState.ts

@@ -1,9 +1,7 @@
-import type { Configuration } from '../domain/configuration'
 import { noop } from '../tools/utils/functionUtils'
 import { DOM_EVENT, addEventListener } from './addEventListener'
 
 export function runOnReadyState(
-  configuration: Configuration,
   expectedReadyState: 'complete' | 'interactive',
   callback: () => void
 ): { stop: () => void } {
@@ -12,14 +10,11 @@ export function runOnReadyState(
     return { stop: noop }
   }
   const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED
-  return addEventListener(configuration, window, eventName, callback, { once: true })
+  return addEventListener(window, eventName, callback, { once: true })
 }
 
-export function asyncRunOnReadyState(
-  configuration: Configuration,
-  expectedReadyState: 'complete' | 'interactive'
-): Promise<void> {
+export function asyncRunOnReadyState(expectedReadyState: 'complete' | 'interactive'): Promise<void> {
   return new Promise((resolve) => {
-    runOnReadyState(configuration, expectedReadyState, resolve)
+    runOnReadyState(expectedReadyState, resolve)
   })
 }

package/src/browser/xhrObservable.ts

@@ -1,11 +1,10 @@
+import { elapsed, timeStampNow, clocksNow } from '@openobserve/js-core/time'
+import type { Duration, ClocksState } from '@openobserve/js-core/time'
 import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
 import { instrumentMethod } from '../tools/instrumentMethod'
 import { Observable } from '../tools/observable'
-import type { Duration, ClocksState } from '../tools/utils/timeUtils'
-import { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils'
 import { normalizeUrl } from '../tools/utils/urlPolyfill'
-import { shallowClone } from '../tools/utils/objectUtils'
-import type { Configuration } from '../domain/configuration'
+import { globalObject } from '../tools/globalObject'
 import { addEventListener } from './addEventListener'
 
 export interface XhrOpenContext {
@@ -35,14 +34,18 @@ export type XhrContext = XhrOpenContext | XhrStartContext | XhrCompleteContext
 let xhrObservable: Observable<XhrContext> | undefined
 const xhrContexts = new WeakMap<XMLHttpRequest, XhrContext>()
 
-export function initXhrObservable(configuration: Configuration) {
+export function initXhrObservable() {
   if (!xhrObservable) {
-    xhrObservable = createXhrObservable(configuration)
+    xhrObservable = createXhrObservable()
   }
   return xhrObservable
 }
 
-function createXhrObservable(configuration: Configuration) {
+function createXhrObservable() {
+  if (!('XMLHttpRequest' in globalObject)) {
+    return new Observable<XhrContext>()
+  }
+
   return new Observable<XhrContext>((observable) => {
     const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)
 
@@ -50,7 +53,7 @@ function createXhrObservable(configuration: Configuration) {
       XMLHttpRequest.prototype,
       'send',
       (call) => {
-        sendXhr(call, configuration, observable)
+        sendXhr(call, observable)
       },
       { computeHandlingStack: true }
     )
@@ -75,7 +78,6 @@ function openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodC
 
 function sendXhr(
   { target: xhr, parameters: [body], handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
-  configuration: Configuration,
   observable: Observable<XhrContext>
 ) {
   const context = xhrContexts.get(xhr)
@@ -112,16 +114,15 @@ function sendXhr(
     hasBeenReported = true
 
     const completeContext = context as XhrCompleteContext
-    completeContext.state = 'complete'
     completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
     completeContext.status = xhr.status
     if (typeof xhr.response === 'string') {
       completeContext.responseBody = xhr.response
     }
-    observable.notify(shallowClone(completeContext))
+    observable.notify({ ...completeContext, state: 'complete' })
   }
 
-  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd)
+  const { stop: unsubscribeLoadEndListener } = addEventListener(xhr, 'loadend', onEnd)
 
   observable.notify(startContext)
 }
@@ -132,3 +133,12 @@ function abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort
     context.isAborted = true
   }
 }
+
+/**
+ * Reset the XHR observable global state. This is useful for testing to ensure clean state between tests.
+ *
+ * @internal
+ */
+export function resetXhrObservable() {
+  xhrObservable = undefined
+}

package/src/domain/allowedTrackingOrigins.ts

@@ -1,5 +1,7 @@
 import { display } from '../tools/display'
+import { globalObject } from '../tools/globalObject'
 import { matchList } from '../tools/matchOption'
+import { mockable } from '../tools/mockable'
 import type { InitConfiguration } from './configuration'
 import { isUnsupportedExtensionEnvironment } from './extension/extensionUtils'
 
@@ -7,11 +9,9 @@ export const ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN =
   'Running the Browser SDK in a Web extension content script is forbidden unless the `allowedTrackingOrigins` option is provided.'
 export const ERROR_NOT_ALLOWED_TRACKING_ORIGIN = 'SDK initialized on a non-allowed domain.'
 
-export function isAllowedTrackingOrigins(
-  configuration: InitConfiguration,
-  errorStack: string,
-  windowOrigin = typeof location !== 'undefined' ? location.origin : ''
-): boolean {
+export function isAllowedTrackingOrigins(configuration: InitConfiguration, errorStack: string): boolean {
+  const location = mockable(globalObject.location)
+  const windowOrigin = location ? location.origin : ''
   const allowedTrackingOrigins = configuration.allowedTrackingOrigins
   if (!allowedTrackingOrigins) {
     if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {

package/src/domain/bufferedData.ts

@@ -1,32 +1,59 @@
+import { ConsoleApiName } from '@openobserve/js-core/util'
+import type { Observable, Subscription } from '../tools/observable'
 import { BufferedObservable } from '../tools/observable'
+import { mockable } from '../tools/mockable'
+import type { FetchContext } from '../browser/fetchObservable'
+import { initFetchObservable } from '../browser/fetchObservable'
+import type { XhrContext } from '../browser/xhrObservable'
+import { initXhrObservable } from '../browser/xhrObservable'
+import { addTelemetryDebug } from './telemetry'
 import type { RawError } from './error/error.types'
 import { trackRuntimeError } from './error/trackRuntimeError'
+import type { ConsoleLog } from './console/consoleObservable'
+import { initConsoleObservable } from './console/consoleObservable'
 
 const BUFFER_LIMIT = 500
 
 export const enum BufferedDataType {
   RUNTIME_ERROR,
+  FETCH,
+  XHR,
+  CONSOLE,
 }
 
-export interface BufferedData {
-  type: BufferedDataType.RUNTIME_ERROR
-  error: RawError
-}
-
-export function startBufferingData(trackRuntimeErrorImpl = trackRuntimeError) {
-  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT)
+export type BufferedData =
+  | { type: BufferedDataType.RUNTIME_ERROR; data: RawError }
+  | { type: BufferedDataType.FETCH; data: FetchContext }
+  | { type: BufferedDataType.XHR; data: XhrContext }
+  | { type: BufferedDataType.CONSOLE; data: ConsoleLog }
 
-  const runtimeErrorSubscription = trackRuntimeErrorImpl().subscribe((error) => {
-    observable.notify({
-      type: BufferedDataType.RUNTIME_ERROR,
-      error,
+export function startBufferingData() {
+  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT, (count) => {
+    // monitor-until: 2026-10-14
+    addTelemetryDebug('Early data collection dropped data on unbuffer', {
+      count,
     })
   })
+  const subscriptions: Subscription[] = []
+
+  function subscribe<T extends BufferedDataType>(
+    type: T,
+    source: Observable<Extract<BufferedData, { type: T }>['data']>
+  ) {
+    subscriptions.push(
+      source.subscribe((data) => {
+        observable.notify({ type, data } as BufferedData)
+      })
+    )
+  }
+
+  subscribe(BufferedDataType.RUNTIME_ERROR, mockable(trackRuntimeError)())
+  subscribe(BufferedDataType.FETCH, initFetchObservable())
+  subscribe(BufferedDataType.XHR, initXhrObservable())
+  subscribe(BufferedDataType.CONSOLE, initConsoleObservable(Object.values(ConsoleApiName)))
 
   return {
     observable,
-    stop: () => {
-      runtimeErrorSubscription.unsubscribe()
-    },
+    stop: () => subscriptions.forEach((subscription) => subscription.unsubscribe()),
   }
 }