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

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "@openobserve/browser-core",
-  "version": "0.2.11-rc1",
+  "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,13 +1,10 @@
 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 }
 
-// We want to use a real enum (i.e. not a const enum) here, to be able to iterate over it to automatically add _ddIsTrusted in e2e tests
-// eslint-disable-next-line no-restricted-syntax
-export enum DOM_EVENT {
+export const enum DOM_EVENT {
   BEFORE_UNLOAD = 'beforeunload',
   CLICK = 'click',
   DBL_CLICK = 'dblclick',
@@ -75,7 +72,9 @@ type EventMapFor<T> = T extends Window
               ? PerformanceEventMap
               : T extends Worker
                 ? WorkerEventMap
-                : Record<never, never>
+                : T extends CookieStore
+                  ? CookieStoreEventMap
+                  : Record<never, never>
 
 /**
  * Add an event listener to an event target object (Window, Element, mock object...).  This provides
@@ -88,7 +87,7 @@ 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] & { type: EventName }) => void,
@@ -110,7 +109,7 @@ 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,
+  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventNames: EventName[],
   listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
@@ -128,11 +127,15 @@ export function addEventListeners<Target extends EventTarget, EventName extends
 
   const options = passive ? { capture, passive } : capture
 
-  const add = getZoneJsOriginalValue(eventTarget, 'addEventListener')
+  // 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')
+    const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener')
     eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options))
   }
 

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,6 +1,12 @@
 import { display } from '../tools/display'
 import { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
-import { findCommaSeparatedValue, findCommaSeparatedValues, 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
@@ -9,7 +15,7 @@ export interface CookieOptions {
   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()}`
@@ -20,15 +26,28 @@ export function setCookie(name: string, value: string, expireDelay: number, opti
   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) {
@@ -70,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,10 +1,14 @@
 import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
 import { instrumentMethod } from '../tools/instrumentMethod'
-import { 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
@@ -12,6 +16,7 @@ interface FetchContextBase {
   input: unknown
   init?: RequestInit
   url: string
+  handlingStack?: string
 }
 
 export interface FetchStartContext extends FetchContextBase {
@@ -22,6 +27,7 @@ export interface FetchResolveContext extends FetchContextBase {
   state: 'resolve'
   status: number
   response?: Response
+  responseBody?: string
   responseType?: string
   isAborted: boolean
   error?: Error
@@ -29,29 +35,54 @@ 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() {
   return new Observable<FetchContext>((observable) => {
-    if (!window.fetch) {
+    if (!globalObject.fetch) {
       return
     }
 
-    const { stop } = instrumentMethod(window, 'fetch', (call) => beforeSend(call, observable))
+    const { stop } = instrumentMethod(globalObject, 'fetch', (call) => beforeSend(call, observable), {
+      computeHandlingStack: true,
+    })
 
     return stop
   })
 }
 
 function beforeSend(
-  { parameters, onPostCall }: InstrumentedMethodCall<Window, 'fetch'>,
+  { parameters, onPostCall, handlingStack }: InstrumentedMethodCall<GlobalObject, 'fetch'>,
   observable: Observable<FetchContext>
 ) {
   const [input, init] = parameters
@@ -72,6 +103,7 @@ function beforeSend(
     method,
     startClocks,
     url,
+    handlingStack,
   }
 
   observable.notify(context)
@@ -80,29 +112,56 @@ function beforeSend(
   parameters[0] = context.input as RequestInfo | URL
   parameters[1] = context.init
 
-  onPostCall((responsePromise) => afterSend(observable, responsePromise, context))
+  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> {
-  return new Observable<PageExitEvent>((observable) => {
-    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,12 +40,9 @@ 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()
@@ -62,6 +51,6 @@ export function createPageExitObservable(configuration: Configuration): Observab
   })
 }
 
-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)
 }

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

@@ -19,12 +19,15 @@ export interface XhrStartContext extends Omit<XhrOpenContext, 'state'> {
   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
@@ -43,9 +46,14 @@ function createXhrObservable(configuration: Configuration) {
   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)
-    })
+    const { stop: stopInstrumentingSend } = instrumentMethod(
+      XMLHttpRequest.prototype,
+      'send',
+      (call) => {
+        sendXhr(call, configuration, observable)
+      },
+      { computeHandlingStack: true }
+    )
 
     const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr)
 
@@ -66,7 +74,7 @@ function openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodC
 }
 
 function sendXhr(
-  { target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
+  { target: xhr, parameters: [body], handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
   configuration: Configuration,
   observable: Observable<XhrContext>
 ) {
@@ -80,6 +88,8 @@ function sendXhr(
   startContext.startClocks = clocksNow()
   startContext.isAborted = false
   startContext.xhr = xhr
+  startContext.handlingStack = handlingStack
+  startContext.requestBody = body
 
   let hasBeenReported = false
 
@@ -105,6 +115,9 @@ function sendXhr(
     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))
   }