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

package/src/browser/runOnReadyState.ts

@@ -1,15 +1,25 @@
 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 } {
   if (document.readyState === expectedReadyState || document.readyState === 'complete') {
     callback()
-  } else {
-    const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED
-    addEventListener(configuration, window, eventName, callback, { once: true })
+    return { stop: noop }
   }
+  const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED
+  return addEventListener(configuration, window, eventName, callback, { once: true })
+}
+
+export function asyncRunOnReadyState(
+  configuration: Configuration,
+  expectedReadyState: 'complete' | 'interactive'
+): Promise<void> {
+  return new Promise((resolve) => {
+    runOnReadyState(configuration, expectedReadyState, resolve)
+  })
 }

package/src/browser/xhrObservable.ts

@@ -1,7 +1,8 @@
-import { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod'
+import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
+import { instrumentMethod } from '../tools/instrumentMethod'
 import { Observable } from '../tools/observable'
-import type { Duration, RelativeTime, ClocksState } from '../tools/utils/timeUtils'
-import { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/utils/timeUtils'
+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'
@@ -15,16 +16,18 @@ export interface XhrOpenContext {
 
 export interface XhrStartContext extends Omit<XhrOpenContext, 'state'> {
   state: 'start'
-  startTime: RelativeTime // deprecated
   startClocks: ClocksState
   isAborted: boolean
   xhr: XMLHttpRequest
+  handlingStack?: string
+  requestBody?: unknown
 }
 
 export interface XhrCompleteContext extends Omit<XhrStartContext, 'state'> {
   state: 'complete'
   duration: Duration
   status: number
+  responseBody?: string
 }
 
 export type XhrContext = XhrOpenContext | XhrStartContext | XhrCompleteContext
@@ -40,20 +43,19 @@ export function initXhrObservable(configuration: Configuration) {
 }
 
 function createXhrObservable(configuration: Configuration) {
-  const observable = new Observable<XhrContext>(() => {
-    const { stop: stopInstrumentingStart } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {
-      before: openXhr,
-    })
-
-    const { stop: stopInstrumentingSend } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {
-      before() {
-        sendXhr.call(this, configuration, observable)
+  return new Observable<XhrContext>((observable) => {
+    const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)
+
+    const { stop: stopInstrumentingSend } = instrumentMethod(
+      XMLHttpRequest.prototype,
+      'send',
+      (call) => {
+        sendXhr(call, configuration, observable)
       },
-    })
+      { computeHandlingStack: true }
+    )
 
-    const { stop: stopInstrumentingAbort } = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {
-      before: abortXhr,
-    })
+    const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr)
 
     return () => {
       stopInstrumentingStart()
@@ -61,42 +63,44 @@ function createXhrObservable(configuration: Configuration) {
       stopInstrumentingAbort()
     }
   })
-  return observable
 }
 
-function openXhr(this: XMLHttpRequest, method: string, url: string | URL | undefined | null) {
-  xhrContexts.set(this, {
+function openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodCall<XMLHttpRequest, 'open'>) {
+  xhrContexts.set(xhr, {
     state: 'open',
-    method,
+    method: String(method).toUpperCase(),
     url: normalizeUrl(String(url)),
   })
 }
 
-function sendXhr(this: XMLHttpRequest, configuration: Configuration, observable: Observable<XhrContext>) {
-  const context = xhrContexts.get(this)
+function sendXhr(
+  { target: xhr, parameters: [body], handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
+  configuration: Configuration,
+  observable: Observable<XhrContext>
+) {
+  const context = xhrContexts.get(xhr)
   if (!context) {
     return
   }
 
   const startContext = context as XhrStartContext
   startContext.state = 'start'
-  startContext.startTime = relativeNow()
   startContext.startClocks = clocksNow()
   startContext.isAborted = false
-  startContext.xhr = this
+  startContext.xhr = xhr
+  startContext.handlingStack = handlingStack
+  startContext.requestBody = body
 
   let hasBeenReported = false
 
-  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {
-    before() {
-      if (this.readyState === XMLHttpRequest.DONE) {
-        // Try to report the XHR as soon as possible, because the XHR may be mutated by the
-        // application during a future event. For example, Angular is calling .abort() on
-        // completed requests during a onreadystatechange event, so the status becomes '0'
-        // before the request is collected.
-        onEnd()
-      }
-    },
+  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      // Try to report the XHR as soon as possible, because the XHR may be mutated by the
+      // application during a future event. For example, Angular is calling .abort() on
+      // completed requests during an onreadystatechange event, so the status becomes '0'
+      // before the request is collected.
+      onEnd()
+    }
   })
 
   const onEnd = () => {
@@ -110,17 +114,20 @@ function sendXhr(this: XMLHttpRequest, configuration: Configuration, observable:
     const completeContext = context as XhrCompleteContext
     completeContext.state = 'complete'
     completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
-    completeContext.status = this.status
+    completeContext.status = xhr.status
+    if (typeof xhr.response === 'string') {
+      completeContext.responseBody = xhr.response
+    }
     observable.notify(shallowClone(completeContext))
   }
 
-  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, this, 'loadend', onEnd)
+  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd)
 
   observable.notify(startContext)
 }
 
-function abortXhr(this: XMLHttpRequest) {
-  const context = xhrContexts.get(this) as XhrStartContext | undefined
+function abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort'>) {
+  const context = xhrContexts.get(xhr) as XhrStartContext | undefined
   if (context) {
     context.isAborted = true
   }

package/src/domain/allowedTrackingOrigins.ts

@@ -0,0 +1,30 @@
+import { display } from '../tools/display'
+import { matchList } from '../tools/matchOption'
+import type { InitConfiguration } from './configuration'
+import { isUnsupportedExtensionEnvironment } from './extension/extensionUtils'
+
+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 {
+  const allowedTrackingOrigins = configuration.allowedTrackingOrigins
+  if (!allowedTrackingOrigins) {
+    if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {
+      display.error(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN)
+
+      return false
+    }
+    return true
+  }
+
+  const isAllowed = matchList(allowedTrackingOrigins, windowOrigin)
+  if (!isAllowed) {
+    display.error(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+  }
+  return isAllowed
+}

package/src/domain/bufferedData.ts

@@ -0,0 +1,32 @@
+import { BufferedObservable } from '../tools/observable'
+import type { RawError } from './error/error.types'
+import { trackRuntimeError } from './error/trackRuntimeError'
+
+const BUFFER_LIMIT = 500
+
+export const enum BufferedDataType {
+  RUNTIME_ERROR,
+}
+
+export interface BufferedData {
+  type: BufferedDataType.RUNTIME_ERROR
+  error: RawError
+}
+
+export function startBufferingData(trackRuntimeErrorImpl = trackRuntimeError) {
+  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT)
+
+  const runtimeErrorSubscription = trackRuntimeErrorImpl().subscribe((error) => {
+    observable.notify({
+      type: BufferedDataType.RUNTIME_ERROR,
+      error,
+    })
+  })
+
+  return {
+    observable,
+    stop: () => {
+      runtimeErrorSubscription.unsubscribe()
+    },
+  }
+}