@openobserve/browser-core 0.2.9 → 0.2.11-rc1

package/src/domain/telemetry/telemetry.ts

@@ -4,8 +4,6 @@ import { toStackTraceString, NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/err
 import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
 import type { Configuration } from '../configuration'
 import { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration'
-import type { StackTrace } from '../tracekit'
-import { computeStackTrace } from '../tracekit'
 import { Observable } from '../../tools/observable'
 import { timeStampNow } from '../../tools/utils/timeUtils'
 import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'
@@ -15,8 +13,11 @@ import { performDraw } from '../../tools/utils/numberUtils'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
 import { combine } from '../../tools/mergeInto'
 import { NonErrorPrefix } from '../error/error.types'
+import type { StackTrace } from '../error/computeStackTrace'
+import { computeStackTrace } from '../error/computeStackTrace'
+import { getConnectivity } from '../connectivity'
 import type { TelemetryEvent } from './telemetryEvent.types'
-import type { RawTelemetryConfiguration, RawTelemetryEvent } from './rawTelemetryEvent.types'
+import type { RawTelemetryConfiguration, RawTelemetryEvent, RuntimeEnvInfo } from './rawTelemetryEvent.types'
 import { StatusType, TelemetryType } from './rawTelemetryEvent.types'
 
 // replaced at build time
@@ -58,9 +59,10 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
   telemetryConfiguration.telemetryConfigurationEnabled =
     telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate)
 
+  const runtimeEnvInfo = getRuntimeEnvInfo()
   onRawTelemetryEventCollected = (rawEvent: RawTelemetryEvent) => {
     if (telemetryConfiguration.telemetryEnabled) {
-      const event = toTelemetryEvent(telemetryService, rawEvent)
+      const event = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo)
       observable.notify(event)
       sendToExtension('telemetry', event)
     }
@@ -72,7 +74,11 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
     sentEventCount: 0,
   })
 
-  function toTelemetryEvent(telemetryService: TelemetryService, event: RawTelemetryEvent): TelemetryEvent & Context {
+  function toTelemetryEvent(
+    telemetryService: TelemetryService,
+    event: RawTelemetryEvent,
+    runtimeEnvInfo: RuntimeEnvInfo
+  ): TelemetryEvent & Context {
     return combine(
       {
         type: 'telemetry' as const,
@@ -83,11 +89,14 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
         _oo: {
           format_version: 2 as const,
         },
-        telemetry: event as any, // https://github.com/microsoft/TypeScript/issues/48457
+        telemetry: combine(event, {
+          runtime_env: runtimeEnvInfo,
+          connectivity: getConnectivity(),
+        }),
         experimental_features: arrayFrom(getExperimentalFeatures()),
       },
       contextProvider !== undefined ? contextProvider() : {}
-    )
+    ) as TelemetryEvent & Context
   }
 
   return {
@@ -98,6 +107,12 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
     enabled: telemetryConfiguration.telemetryEnabled,
   }
 }
+function getRuntimeEnvInfo(): RuntimeEnvInfo {
+  return {
+    is_local_file: window.location.protocol === 'file:',
+    is_worker: 'WorkerGlobalScope' in self,
+  }
+}
 
 export function startFakeTelemetry() {
   const events: RawTelemetryEvent[] = []

package/src/domain/telemetry/telemetryEvent.types.ts

@@ -142,9 +142,13 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        */
       track_long_task?: boolean
       /**
-       * Whether a secure cross-site session cookie is used
+       * Whether a secure cross-site session cookie is used (deprecated)
        */
       use_cross_site_session_cookie?: boolean
+      /**
+       * Whether a partitioned secure cross-site session cookie is used
+       */
+      use_partitioned_cross_site_session_cookie?: boolean
       /**
        * Whether a secure session cookie is used
        */
@@ -153,6 +157,10 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether it is allowed to use LocalStorage when cookies are not available
        */
       allow_fallback_to_local_storage?: boolean
+      /**
+       * Whether contexts are stored in local storage
+       */
+      store_contexts_across_pages?: boolean
       /**
        * Whether untrusted events are allowed
        */
@@ -281,6 +289,14 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * The upload frequency of batches (in milliseconds)
        */
       batch_upload_frequency?: number
+      /**
+       * Maximum number of batches processed sequencially without a delay
+       */
+      batch_processing_level?: number
+      /**
+       * Whether UIApplication background tasks are enabled
+       */
+      background_tasks_enabled?: boolean
       /**
        * The version of React used in a ReactNative application
        */
@@ -329,7 +345,7 @@ export interface CommonTelemetryProperties {
   /**
    * The source of this event
    */
-  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native'
+  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native' | 'unity'
   /**
    * The version of the SDK generating the telemetry event
    */

package/src/index.ts

@@ -5,7 +5,6 @@ export {
   DefaultPrivacyLevel,
   EndpointBuilder,
   serializeConfiguration,
-  INTAKE_SITE_AP1,
   INTAKE_SITE_STAGING,
   INTAKE_SITE_US1,
   INTAKE_SITE_US1_FED,
@@ -19,7 +18,7 @@ export {
   ExperimentalFeature,
 } from './tools/experimentalFeatures'
 export { trackRuntimeError } from './domain/error/trackRuntimeError'
-export { computeStackTrace, StackTrace } from './domain/tracekit'
+export { computeStackTrace, StackTrace } from './domain/error/computeStackTrace'
 export { defineGlobal, makePublicApi } from './boot/init'
 export { initReportObservable, RawReport, RawReportType } from './domain/report/reportObservable'
 export {
@@ -62,6 +61,7 @@ export {
   FlushReason,
 } from './transport'
 export * from './tools/display'
+export { Encoder, EncoderResult, createIdentityEncoder } from './tools/encoder'
 export * from './tools/utils/urlPolyfill'
 export * from './tools/utils/timeUtils'
 export * from './tools/utils/arrayUtils'
@@ -73,7 +73,7 @@ export * from './tools/utils/browserDetection'
 export { sendToExtension } from './tools/sendToExtension'
 export { runOnReadyState } from './browser/runOnReadyState'
 export { getZoneJsOriginalValue } from './tools/getZoneJsOriginalValue'
-export { instrumentMethod, instrumentMethodAndCallOriginal, instrumentSetter } from './tools/instrumentMethod'
+export { instrumentMethod, instrumentSetter, InstrumentedMethodCall } from './tools/instrumentMethod'
 export {
   computeRawError,
   createHandlingStack,
@@ -92,12 +92,17 @@ export * from './tools/timer'
 export { initConsoleObservable, resetConsoleObservable, ConsoleLog } from './domain/console/consoleObservable'
 export { BoundedBuffer } from './tools/boundedBuffer'
 export { catchUserErrors } from './tools/catchUserErrors'
-export { createContextManager, ContextManager } from './tools/serialisation/contextManager'
+export { createContextManager, ContextManager } from './domain/context/contextManager'
+export { storeContextManager, removeStorageListeners } from './domain/context/storeContextManager'
 export {
-  warnIfCustomerDataLimitReached,
-  CustomerDataType,
+  createCustomerDataTrackerManager,
+  createCustomerDataTracker,
+  CustomerDataTracker,
+  CustomerDataTrackerManager,
   CUSTOMER_DATA_BYTES_LIMIT,
-} from './tools/serialisation/heavyCustomerDataWarning'
+  CustomerDataCompressionStatus,
+} from './domain/context/customerDataTracker'
+export { CustomerDataType } from './domain/context/contextConstants'
 export { ValueHistory, ValueHistoryEntry, CLEAR_OLD_VALUES_INTERVAL } from './tools/valueHistory'
 export { readBytesFromStream } from './tools/readBytesFromStream'
 export { STORAGE_POLL_DELAY } from './domain/session/sessionStore'
@@ -126,3 +131,4 @@ export { RawError } from './domain/error/error.types'
 export { RawErrorCause } from './domain/error/error.types'
 export { ErrorWithCause } from './domain/error/error.types'
 export * from './domain/deflate'
+export * from './domain/connectivity'

package/src/tools/display.ts

@@ -18,7 +18,6 @@ export const ConsoleApiName = {
 export type ConsoleApiName = (typeof ConsoleApiName)[keyof typeof ConsoleApiName]
 
 interface Display {
-  (api: ConsoleApiName, ...args: any[]): void
   debug: typeof console.debug
   log: typeof console.log
   info: typeof console.info
@@ -26,13 +25,6 @@ interface Display {
   error: typeof console.error
 }
 
-export const display: Display = (api, ...args) => {
-  if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {
-    api = ConsoleApiName.log
-  }
-  display[api](...args)
-}
-
 /**
  * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove
  * "console.*" references. This causes some issue as we expect `console.*` to be defined.
@@ -44,8 +36,17 @@ export const display: Display = (api, ...args) => {
  */
 export const globalConsole = console
 
-display.debug = globalConsole.debug.bind(globalConsole)
-display.log = globalConsole.log.bind(globalConsole)
-display.info = globalConsole.info.bind(globalConsole)
-display.warn = globalConsole.warn.bind(globalConsole)
-display.error = globalConsole.error.bind(globalConsole)
+export const originalConsoleMethods = {} as Display
+Object.keys(ConsoleApiName).forEach((name) => {
+  originalConsoleMethods[name as ConsoleApiName] = globalConsole[name as ConsoleApiName]
+})
+
+const PREFIX = 'Datadog Browser SDK:'
+
+export const display: Display = {
+  debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),
+  log: originalConsoleMethods.log.bind(globalConsole, PREFIX),
+  info: originalConsoleMethods.info.bind(globalConsole, PREFIX),
+  warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),
+  error: originalConsoleMethods.error.bind(globalConsole, PREFIX),
+}

package/src/tools/encoder.ts

@@ -0,0 +1,102 @@
+import { computeBytesCount } from './utils/byteUtils'
+
+export interface Encoder<Output extends string | Uint8Array = string | Uint8Array> {
+  /**
+   * Whether this encoder might call the provided callbacks asynchronously
+   */
+  isAsync: boolean
+
+  /**
+   * Whether some data has been written since the last finish() or finishSync() call
+   */
+  isEmpty: boolean
+
+  /**
+   * Write a string to be encoded.
+   *
+   * This operation can be synchronous or asynchronous depending on the encoder implementation.
+   *
+   * If specified, the callback will be invoked when the operation finishes, unless the operation is
+   * asynchronous and finish() or finishSync() is called in the meantime.
+   */
+  write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void
+
+  /**
+   * Waits for pending data to be encoded and resets the encoder state.
+   *
+   * This operation can be synchronous or asynchronous depending on the encoder implementation.
+   *
+   * The callback will be invoked when the operation finishes, unless the operation is asynchronous
+   * and another call to finish() or finishSync() occurs in the meantime.
+   */
+  finish(callback: (result: EncoderResult<Output>) => void): void
+
+  /**
+   * Resets the encoder state then returns the encoded data and any potential pending data directly,
+   * discarding all pending write operations and finish() callbacks.
+   */
+  finishSync(): EncoderResult<Output> & { pendingData: string }
+
+  /**
+   * Returns a rough estimation of the bytes count if the data was encoded.
+   */
+  estimateEncodedBytesCount(data: string): number
+}
+
+export interface EncoderResult<Output extends string | Uint8Array = string | Uint8Array> {
+  output: Output
+  outputBytesCount: number
+
+  /**
+   * An encoding type supported by HTTP Content-Encoding, if applicable.
+   * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives
+   */
+  encoding?: 'deflate'
+
+  /**
+   * Total bytes count of the input strings encoded to UTF-8.
+   */
+  rawBytesCount: number
+}
+
+export function createIdentityEncoder(): Encoder<string> {
+  let output = ''
+  let outputBytesCount = 0
+
+  return {
+    isAsync: false,
+
+    get isEmpty() {
+      return !output
+    },
+
+    write(data, callback) {
+      const additionalEncodedBytesCount = computeBytesCount(data)
+      outputBytesCount += additionalEncodedBytesCount
+      output += data
+      if (callback) {
+        callback(additionalEncodedBytesCount)
+      }
+    },
+
+    finish(callback) {
+      callback(this.finishSync())
+    },
+
+    finishSync() {
+      const result = {
+        output,
+        outputBytesCount,
+        rawBytesCount: outputBytesCount,
+        pendingData: '',
+      }
+      output = ''
+      outputBytesCount = 0
+      return result
+    },
+
+    estimateEncodedBytesCount(data) {
+      return data.length
+    },
+  }
+}

package/src/tools/experimentalFeatures.ts

@@ -14,12 +14,10 @@ export enum ExperimentalFeature {
   PAGEHIDE = 'pagehide',
   FEATURE_FLAGS = 'feature_flags',
   RESOURCE_PAGE_STATES = 'resource_page_states',
-  PAGE_STATES = 'page_states',
   COLLECT_FLUSH_REASON = 'collect_flush_reason',
-  NO_RESOURCE_DURATION_FROZEN_STATE = 'no_resource_duration_frozen_state',
-  SCROLLMAP = 'scrollmap',
-  INTERACTION_TO_NEXT_PAINT = 'interaction_to_next_paint',
+  ZERO_LCP_TELEMETRY = 'zero_lcp_telemetry',
   DISABLE_REPLAY_INLINE_CSS = 'disable_replay_inline_css',
+  WRITABLE_RESOURCE_GRAPHQL = 'writable_resource_graphql',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()

package/src/tools/instrumentMethod.ts

@@ -2,30 +2,77 @@ import { setTimeout } from './timer'
 import { callMonitored } from './monitor'
 import { noop } from './utils/functionUtils'
 
-export function instrumentMethod<OBJECT extends { [key: string]: any }, METHOD extends keyof OBJECT>(
-  object: OBJECT,
+/**
+ * Object passed to the callback of an instrumented method call. See `instrumentMethod` for more
+ * info.
+ */
+export type InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = {
+  /**
+   * The target object on which the method was called.
+   */
+  target: TARGET
+
+  /**
+   * The parameters with which the method was called. To avoid having to clone the argument list
+   * every time, this property is actually an instance of Argument, not Array, so not all methods
+   * are available (like .forEach).
+   *
+   * Note: if needed, parameters can be mutated by the instrumentation
+   */
+  parameters: Parameters<TARGET[METHOD]>
+
+  /**
+   * Registers a callback that will be called after the original method is called, with the method
+   * result passed as argument.
+   */
+  onPostCall: (callback: PostCallCallback<TARGET, METHOD>) => void
+}
+
+type PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = (
+  result: ReturnType<TARGET[METHOD]>
+) => void
+
+/**
+ * Instruments a method on a object, calling the given callback before the original method is
+ * invoked. The callback receives an object with information about the method call.
+ *
+ * Note: it is generally better to instrument methods that are "owned" by the object instead of ones
+ * that are inherited from the prototype chain. Example:
+ * * do:    `instrumentMethod(Array.prototype, 'push', ...)`
+ * * don't: `instrumentMethod([], 'push', ...)`
+ *
+ * @example
+ *
+ *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
+ *    console.log('Before calling fetch on', target, 'with parameters', parameters)
+ *
+ *    onPostCall((result) => {
+ *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)
+ *    })
+ *  })
+ */
+export function instrumentMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(
+  targetPrototype: TARGET,
   method: METHOD,
-  instrumentationFactory: (
-    original: OBJECT[METHOD]
-  ) => (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => ReturnType<OBJECT[METHOD]>
+  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void
 ) {
-  const original = object[method]
+  const original = targetPrototype[method]
 
-  let instrumentation = instrumentationFactory(original)
+  let instrumentation = createInstrumentedMethod(original, onPreCall)
 
-  const instrumentationWrapper = function (this: OBJECT): ReturnType<OBJECT[METHOD]> | undefined {
+  const instrumentationWrapper = function (this: TARGET): ReturnType<TARGET[METHOD]> | undefined {
     if (typeof instrumentation !== 'function') {
       return undefined
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return instrumentation.apply(this, arguments as unknown as Parameters<OBJECT[METHOD]>)
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+    return instrumentation.apply(this, arguments as unknown as Parameters<TARGET[METHOD]>)
   }
-  object[method] = instrumentationWrapper as OBJECT[METHOD]
+  targetPrototype[method] = instrumentationWrapper as TARGET[METHOD]
 
   return {
     stop: () => {
-      if (object[method] === instrumentationWrapper) {
-        object[method] = original
+      if (targetPrototype[method] === instrumentationWrapper) {
+        targetPrototype[method] = original
       } else {
         instrumentation = original
       }
@@ -33,74 +80,71 @@ export function instrumentMethod<OBJECT extends { [key: string]: any }, METHOD e
   }
 }
 
-export function instrumentMethodAndCallOriginal<OBJECT extends { [key: string]: any }, METHOD extends keyof OBJECT>(
-  object: OBJECT,
-  method: METHOD,
-  {
-    before,
-    after,
-  }: {
-    before?: (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => void
-    after?: (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => void
-  }
-) {
-  return instrumentMethod(
-    object,
-    method,
-    (original) =>
-      function () {
-        const args = arguments as unknown as Parameters<OBJECT[METHOD]>
-        let result
-
-        if (before) {
-          callMonitored(before, this, args)
-        }
-
-        if (typeof original === 'function') {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-          result = original.apply(this, args)
-        }
-
-        if (after) {
-          callMonitored(after, this, args)
-        }
-
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return result
-      }
-  )
+function createInstrumentedMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(
+  original: TARGET[METHOD],
+  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void
+): TARGET[METHOD] {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return function (this: TARGET) {
+    const parameters = arguments as unknown as Parameters<TARGET[METHOD]>
+    let result
+
+    let postCallCallback: PostCallCallback<TARGET, METHOD> | undefined
+
+    callMonitored(onPreCall, null, [
+      {
+        target: this,
+        parameters,
+        onPostCall: (callback) => {
+          postCallCallback = callback
+        },
+      },
+    ])
+
+    if (typeof original === 'function') {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      result = original.apply(this, parameters)
+    }
+
+    if (postCallCallback) {
+      callMonitored(postCallCallback, null, [result])
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return result
+  } as TARGET[METHOD]
 }
 
-export function instrumentSetter<OBJECT extends { [key: string]: any }, PROPERTY extends keyof OBJECT>(
-  object: OBJECT,
+export function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY extends keyof TARGET>(
+  targetPrototype: TARGET,
   property: PROPERTY,
-  after: (thisObject: OBJECT, value: OBJECT[PROPERTY]) => void
+  after: (target: TARGET, value: TARGET[PROPERTY]) => void
 ) {
-  const originalDescriptor = Object.getOwnPropertyDescriptor(object, property)
+  const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property)
   if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
     return { stop: noop }
   }
 
-  let instrumentation = (thisObject: OBJECT, value: OBJECT[PROPERTY]) => {
+  let instrumentation = (target: TARGET, value: TARGET[PROPERTY]) => {
     // put hooked setter into event loop to avoid of set latency
     setTimeout(() => {
-      after(thisObject, value)
+      after(target, value)
     }, 0)
   }
 
-  const instrumentationWrapper = function (this: OBJECT, value: OBJECT[PROPERTY]) {
+  const instrumentationWrapper = function (this: TARGET, value: TARGET[PROPERTY]) {
     originalDescriptor.set!.call(this, value)
     instrumentation(this, value)
   }
 
-  Object.defineProperty(object, property, {
+  Object.defineProperty(targetPrototype, property, {
     set: instrumentationWrapper,
   })
 
   return {
     stop: () => {
-      if (Object.getOwnPropertyDescriptor(object, property)?.set === instrumentationWrapper) {
-        Object.defineProperty(object, property, originalDescriptor)
+      if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) {
+        Object.defineProperty(targetPrototype, property, originalDescriptor)
       } else {
         instrumentation = noop
       }

package/src/tools/mergeInto.ts

@@ -5,22 +5,22 @@ type Merged<TDestination, TSource> =
   TSource extends undefined
     ? TDestination
     : // case 2 - destination is undefined - return source
-    TDestination extends undefined
-    ? TSource
-    : // case 3 - source is an array - see if it merges or overwrites
-    TSource extends any[]
-    ? TDestination extends any[]
-      ? TDestination & TSource
-      : TSource
-    : // case 4 - source is an object - see if it merges or overwrites
-    TSource extends object
-    ? TDestination extends object
-      ? TDestination extends any[]
-        ? TSource
-        : TDestination & TSource
-      : TSource
-    : // case 5 - cannot merge - return source
-      TSource
+      TDestination extends undefined
+      ? TSource
+      : // case 3 - source is an array - see if it merges or overwrites
+        TSource extends any[]
+        ? TDestination extends any[]
+          ? TDestination & TSource
+          : TSource
+        : // case 4 - source is an object - see if it merges or overwrites
+          TSource extends object
+          ? TDestination extends object
+            ? TDestination extends any[]
+              ? TSource
+              : TDestination & TSource
+            : TSource
+          : // case 5 - cannot merge - return source
+            TSource
 
 /**
  * Iterate over source and affect its sub values into destination, recursively.

package/src/tools/monitor.ts

@@ -1,4 +1,4 @@
-import { ConsoleApiName, display } from './display'
+import { display } from './display'
 
 let onMonitorErrorCollected: undefined | ((error: unknown) => void)
 let debugMode = false
@@ -50,19 +50,19 @@ export function callMonitored<T extends (...args: any[]) => any>(
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return fn.apply(context, args)
   } catch (e) {
-    displayIfDebugEnabled(ConsoleApiName.error, e)
+    displayIfDebugEnabled(e)
     if (onMonitorErrorCollected) {
       try {
         onMonitorErrorCollected(e)
       } catch (e) {
-        displayIfDebugEnabled(ConsoleApiName.error, e)
+        displayIfDebugEnabled(e)
       }
     }
   }
 }
 
-export function displayIfDebugEnabled(api: ConsoleApiName, ...args: any[]) {
+export function displayIfDebugEnabled(...args: any[]) {
   if (debugMode) {
-    display(api, '[MONITOR]', ...args)
+    display.error('[MONITOR]', ...args)
   }
 }

package/src/tools/observable.ts

@@ -6,11 +6,11 @@ export class Observable<T> {
   private observers: Array<(data: T) => void> = []
   private onLastUnsubscribe?: () => void
 
-  constructor(private onFirstSubscribe?: () => (() => void) | void) {}
+  constructor(private onFirstSubscribe?: (observable: Observable<T>) => (() => void) | void) {}
 
   subscribe(f: (data: T) => void): Subscription {
     if (!this.observers.length && this.onFirstSubscribe) {
-      this.onLastUnsubscribe = this.onFirstSubscribe() || undefined
+      this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined
     }
     this.observers.push(f)
     return {
@@ -29,12 +29,10 @@ export class Observable<T> {
 }
 
 export function mergeObservables<T>(...observables: Array<Observable<T>>) {
-  const globalObservable = new Observable<T>(() => {
+  return new Observable<T>((globalObservable) => {
     const subscriptions: Subscription[] = observables.map((observable) =>
       observable.subscribe((data) => globalObservable.notify(data))
     )
     return () => subscriptions.forEach((subscription) => subscription.unsubscribe())
   })
-
-  return globalObservable
 }