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

package/src/transport/batch.ts

@@ -1,92 +1,144 @@
-import { display } from '../tools/display'
+import { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../tools/display'
 import type { Context } from '../tools/serialisation/context'
 import { objectValues } from '../tools/utils/polyfills'
-import { isPageExitReason } from '../browser/pageExitObservable'
-import { computeBytesCount } from '../tools/utils/byteUtils'
+import { isPageExitReason } from '../browser/pageMayExitObservable'
 import { jsonStringify } from '../tools/serialisation/jsonStringify'
-import type { HttpRequest } from './httpRequest'
+import type { Encoder, EncoderResult } from '../tools/encoder'
+import { computeBytesCount, ONE_KIBI_BYTE } from '../tools/utils/byteUtils'
+import type { HttpRequest, Payload } from './httpRequest'
 import type { FlushController, FlushEvent } from './flushController'
 
-export class Batch {
-  private pushOnlyBuffer: string[] = []
-  private upsertBuffer: { [key: string]: string } = {}
+export const MESSAGE_BYTES_LIMIT = 256 * ONE_KIBI_BYTE
 
-  constructor(
-    private request: HttpRequest,
-    public flushController: FlushController,
-    private messageBytesLimit: number
-  ) {
-    this.flushController.flushObservable.subscribe((event) => this.flush(event))
-  }
+export interface Batch {
+  flushController: FlushController
+  add: (message: Context) => void
+  upsert: (message: Context, key: string) => void
+  stop: () => void
+}
 
-  add(message: Context) {
-    this.addOrUpdate(message)
-  }
+export function createBatch({
+  encoder,
+  request,
+  flushController,
+}: {
+  encoder: Encoder
+  request: HttpRequest
+  flushController: FlushController
+}): Batch {
+  let upsertBuffer: { [key: string]: string } = {}
+  const flushSubscription = flushController.flushObservable.subscribe((event) => flush(event))
+
+  function push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {
+    flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
 
-  upsert(message: Context, key: string) {
-    this.addOrUpdate(message, key)
+    if (key !== undefined) {
+      upsertBuffer[key] = serializedMessage
+      flushController.notifyAfterAddMessage()
+    } else {
+      encoder.write(encoder.isEmpty ? serializedMessage : `\n${serializedMessage}`, (realMessageBytesCount) => {
+        flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)
+      })
+    }
   }
 
-  private flush(event: FlushEvent) {
-    const messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer))
-
-    this.pushOnlyBuffer = []
-    this.upsertBuffer = {}
+  function hasMessageFor(key?: string): key is string {
+    return key !== undefined && upsertBuffer[key] !== undefined
+  }
 
-    const payload = { data: messages.join('\n'), bytesCount: event.bytesCount, flushReason: event.reason }
-    if (isPageExitReason(event.reason)) {
-      this.request.sendOnExit(payload)
-    } else {
-      this.request.send(payload)
-    }
+  function remove(key: string) {
+    const removedMessage = upsertBuffer[key]
+    delete upsertBuffer[key]
+    const messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage)
+    flushController.notifyAfterRemoveMessage(messageBytesCount)
   }
 
-  private addOrUpdate(message: Context, key?: string) {
-    const { processedMessage, messageBytesCount } = this.process(message)
+  function addOrUpdate(message: Context, key?: string) {
+    const serializedMessage = jsonStringify(message)!
+
+    const estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage)
 
-    if (messageBytesCount >= this.messageBytesLimit) {
+    if (estimatedMessageBytesCount >= MESSAGE_BYTES_LIMIT) {
       display.warn(
-        `Discarded a message whose size was bigger than the maximum allowed size ${this.messageBytesLimit}KB.`
+        `Discarded a message whose size was bigger than the maximum allowed size ${MESSAGE_BYTES_LIMIT / ONE_KIBI_BYTE}KiB. ${MORE_DETAILS} ${DOCS_TROUBLESHOOTING}/#technical-limitations`
       )
       return
     }
 
-    if (this.hasMessageFor(key)) {
-      this.remove(key)
+    if (hasMessageFor(key)) {
+      remove(key)
     }
 
-    this.push(processedMessage, messageBytesCount, key)
+    push(serializedMessage, estimatedMessageBytesCount, key)
   }
 
-  private process(message: Context) {
-    const processedMessage = jsonStringify(message)!
-    const messageBytesCount = computeBytesCount(processedMessage)
-    return { processedMessage, messageBytesCount }
-  }
-
-  private push(processedMessage: string, messageBytesCount: number, key?: string) {
-    // If there are other messages, a '\n' will be added at serialization
-    const separatorBytesCount = this.flushController.messagesCount > 0 ? 1 : 0
-
-    this.flushController.notifyBeforeAddMessage(messageBytesCount + separatorBytesCount)
-    if (key !== undefined) {
-      this.upsertBuffer[key] = processedMessage
+  function flush(event: FlushEvent) {
+    const upsertMessages = objectValues(upsertBuffer).join('\n')
+    upsertBuffer = {}
+
+    const pageMightExit = isPageExitReason(event.reason)
+    const send = pageMightExit ? request.sendOnExit : request.send
+
+    if (
+      pageMightExit &&
+      // Note: checking that the encoder is async is not strictly needed, but it's an optimization:
+      // if the encoder is async we need to send two requests in some cases (one for encoded data
+      // and the other for non-encoded data). But if it's not async, we don't have to worry about
+      // it and always send a single request.
+      encoder.isAsync
+    ) {
+      const encoderResult = encoder.finishSync()
+
+      // Send encoded messages
+      if (encoderResult.outputBytesCount) {
+        send(formatPayloadFromEncoder(encoderResult))
+      }
+
+      // Send messages that are not yet encoded at this point
+      const pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join('\n')
+      if (pendingMessages) {
+        send({
+          data: pendingMessages,
+          bytesCount: computeBytesCount(pendingMessages),
+        })
+      }
     } else {
-      this.pushOnlyBuffer.push(processedMessage)
+      if (upsertMessages) {
+        encoder.write(encoder.isEmpty ? upsertMessages : `\n${upsertMessages}`)
+      }
+      encoder.finish((encoderResult) => {
+        send(formatPayloadFromEncoder(encoderResult))
+      })
     }
-    this.flushController.notifyAfterAddMessage()
   }
 
-  private remove(key: string) {
-    const removedMessage = this.upsertBuffer[key]
-    delete this.upsertBuffer[key]
-    const messageBytesCount = computeBytesCount(removedMessage)
-    // If there are other messages, a '\n' will be added at serialization
-    const separatorBytesCount = this.flushController.messagesCount > 1 ? 1 : 0
-    this.flushController.notifyAfterRemoveMessage(messageBytesCount + separatorBytesCount)
+  return {
+    flushController,
+    add: addOrUpdate,
+    upsert: addOrUpdate,
+    stop: flushSubscription.unsubscribe,
+  }
+}
+
+function formatPayloadFromEncoder(encoderResult: EncoderResult): Payload {
+  let data: string | Blob
+  if (typeof encoderResult.output === 'string') {
+    data = encoderResult.output
+  } else {
+    data = new Blob([encoderResult.output], {
+      // This will set the 'Content-Type: text/plain' header. Reasoning:
+      // * The intake rejects the request if there is no content type.
+      // * The browser will issue CORS preflight requests if we set it to 'application/json', which
+      // could induce higher intake load (and maybe has other impacts).
+      // * Also it's not quite JSON, since we are concatenating multiple JSON objects separated by
+      // new lines.
+      type: 'text/plain',
+    })
   }
 
-  private hasMessageFor(key?: string): key is string {
-    return key !== undefined && this.upsertBuffer[key] !== undefined
+  return {
+    data,
+    bytesCount: encoderResult.outputBytesCount,
+    encoding: encoderResult.encoding,
   }
 }

package/src/transport/eventBridge.ts

@@ -1,15 +1,21 @@
-import { endsWith } from '../tools/utils/polyfills'
-import { getGlobalObject } from '../tools/getGlobalObject'
+import { getGlobalObject } from '../tools/globalObject'
+import type { DefaultPrivacyLevel } from '../domain/configuration'
 
 export interface BrowserWindowWithEventBridge extends Window {
   DatadogEventBridge?: DatadogEventBridge
 }
 
 export interface DatadogEventBridge {
+  getCapabilities?(): string
+  getPrivacyLevel?(): DefaultPrivacyLevel
   getAllowedWebViewHosts(): string
   send(msg: string): void
 }
 
+export const enum BridgeCapability {
+  RECORDS = 'records',
+}
+
 export function getEventBridge<T, E>() {
   const eventBridgeGlobal = getEventBridgeGlobal()
 
@@ -18,22 +24,35 @@ export function getEventBridge<T, E>() {
   }
 
   return {
+    getCapabilities() {
+      return JSON.parse(eventBridgeGlobal.getCapabilities?.() || '[]') as BridgeCapability[]
+    },
+    getPrivacyLevel() {
+      return eventBridgeGlobal.getPrivacyLevel?.()
+    },
     getAllowedWebViewHosts() {
       return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts()) as string[]
     },
-    send(eventType: T, event: E) {
-      eventBridgeGlobal.send(JSON.stringify({ eventType, event }))
+    send(eventType: T, event: E, viewId?: string) {
+      const view = viewId ? { id: viewId } : undefined
+      eventBridgeGlobal.send(JSON.stringify({ eventType, event, view }))
     },
   }
 }
 
+export function bridgeSupports(capability: BridgeCapability): boolean {
+  const bridge = getEventBridge()
+  return !!bridge && bridge.getCapabilities().includes(capability)
+}
+
 export function canUseEventBridge(currentHost = getGlobalObject<Window>().location?.hostname): boolean {
   const bridge = getEventBridge()
+
   return (
     !!bridge &&
     bridge
       .getAllowedWebViewHosts()
-      .some((allowedHost) => currentHost === allowedHost || endsWith(currentHost, `.${allowedHost}`))
+      .some((allowedHost) => currentHost === allowedHost || currentHost.endsWith(`.${allowedHost}`))
   )
 }
 

package/src/transport/flushController.ts

@@ -1,11 +1,26 @@
-import type { PageExitEvent, PageExitReason } from '../browser/pageExitObservable'
+import type { PageMayExitEvent, PageExitReason } from '../browser/pageMayExitObservable'
+import { isWorkerEnvironment } from '../tools/globalObject'
 import { Observable } from '../tools/observable'
 import type { TimeoutId } from '../tools/timer'
 import { clearTimeout, setTimeout } from '../tools/timer'
+import { ONE_SECOND } from '../tools/utils/timeUtils'
 import type { Duration } from '../tools/utils/timeUtils'
+import { RECOMMENDED_REQUEST_BYTES_LIMIT } from './httpRequest'
 
 export type FlushReason = PageExitReason | 'duration_limit' | 'bytes_limit' | 'messages_limit' | 'session_expire'
 
+/**
+ * flush automatically, aim to be lower than ALB connection timeout
+ * to maximize connection reuse.
+ */
+export const FLUSH_DURATION_LIMIT = (30 * ONE_SECOND) as Duration
+
+/**
+ * When using the SDK in a Worker Environment, we limit the batch size to 1 to ensure it can be sent
+ * in a single event.
+ */
+export const MESSAGES_LIMIT = isWorkerEnvironment ? 1 : 50
+
 export type FlushController = ReturnType<typeof createFlushController>
 export interface FlushEvent {
   reason: FlushReason
@@ -14,10 +29,7 @@ export interface FlushEvent {
 }
 
 interface FlushControllerOptions {
-  messagesLimit: number
-  bytesLimit: number
-  durationLimit: Duration
-  pageExitObservable: Observable<PageExitEvent>
+  pageMayExitObservable: Observable<PageMayExitEvent>
   sessionExpireObservable: Observable<void>
 }
 
@@ -26,17 +38,14 @@ interface FlushControllerOptions {
  * to happen. The implementation is designed to support both synchronous and asynchronous usages,
  * but relies on invariants described in each method documentation to keep a coherent state.
  */
-export function createFlushController({
-  messagesLimit,
-  bytesLimit,
-  durationLimit,
-  pageExitObservable,
-  sessionExpireObservable,
-}: FlushControllerOptions) {
-  const flushObservable = new Observable<FlushEvent>()
-
-  pageExitObservable.subscribe((event) => flush(event.reason))
-  sessionExpireObservable.subscribe(() => flush('session_expire'))
+export function createFlushController({ pageMayExitObservable, sessionExpireObservable }: FlushControllerOptions) {
+  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => flush(event.reason))
+  const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'))
+
+  const flushObservable = new Observable<FlushEvent>(() => () => {
+    pageMayExitSubscription.unsubscribe()
+    sessionExpireSubscription.unsubscribe()
+  })
 
   let currentBytesCount = 0
   let currentMessagesCount = 0
@@ -65,7 +74,7 @@ export function createFlushController({
     if (durationLimitTimeoutId === undefined) {
       durationLimitTimeoutId = setTimeout(() => {
         flush('duration_limit')
-      }, durationLimit)
+      }, FLUSH_DURATION_LIMIT)
     }
   }
 
@@ -85,16 +94,19 @@ export function createFlushController({
      *
      * This function needs to be called synchronously, right before adding the message, so no flush
      * event can happen after `notifyBeforeAddMessage` and before adding the message.
+     *
+     * @param estimatedMessageBytesCount - an estimation of the message bytes count once it is
+     * actually added.
      */
-    notifyBeforeAddMessage(messageBytesCount: number) {
-      if (currentBytesCount + messageBytesCount >= bytesLimit) {
+    notifyBeforeAddMessage(estimatedMessageBytesCount: number) {
+      if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {
         flush('bytes_limit')
       }
       // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no
       // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want
       // to notify when a flush is needed (for example on page exit).
       currentMessagesCount += 1
-      currentBytesCount += messageBytesCount
+      currentBytesCount += estimatedMessageBytesCount
       scheduleDurationLimitTimeout()
     },
 
@@ -103,11 +115,16 @@ export function createFlushController({
      *
      * This function can be called asynchronously after the message was added, but in this case it
      * should not be called if a flush event occurred in between.
+     *
+     * @param messageBytesCountDiff - the difference between the estimated message bytes count and
+     * its actual bytes count once added to the pool.
      */
-    notifyAfterAddMessage() {
-      if (currentMessagesCount >= messagesLimit) {
+    notifyAfterAddMessage(messageBytesCountDiff = 0) {
+      currentBytesCount += messageBytesCountDiff
+
+      if (currentMessagesCount >= MESSAGES_LIMIT) {
         flush('messages_limit')
-      } else if (currentBytesCount >= bytesLimit) {
+      } else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {
         flush('bytes_limit')
       }
     },
@@ -117,6 +134,10 @@ export function createFlushController({
      *
      * This function needs to be called synchronously, right after removing the message, so no flush
      * event can happen after removing the message and before `notifyAfterRemoveMessage`.
+     *
+     * @param messageBytesCount - the message bytes count that was added to the pool. Should
+     * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and
+     * `notifyAfterAddMessage`.
      */
     notifyAfterRemoveMessage(messageBytesCount: number) {
       currentBytesCount -= messageBytesCount

package/src/transport/httpRequest.ts

@@ -1,11 +1,17 @@
-import type { EndpointBuilder, Configuration } from '../domain/configuration'
-import { addTelemetryError } from '../domain/telemetry'
+import type { EndpointBuilder } from '../domain/configuration'
 import type { Context } from '../tools/serialisation/context'
-import { monitor } from '../tools/monitor'
-import { addEventListener } from '../browser/addEventListener'
+import { monitor, monitorError } from '../tools/monitor'
 import type { RawError } from '../domain/error/error.types'
+import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../tools/experimentalFeatures'
+import { Observable } from '../tools/observable'
+import { ONE_KIBI_BYTE } from '../tools/utils/byteUtils'
 import { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'
-import type { FlushReason } from './flushController'
+
+/**
+ * beacon payload max queue size implementation is 64kb
+ * ensure that we leave room for logs, rum and potential other users
+ */
+export const RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * ONE_KIBI_BYTE
 
 /**
  * Use POST request without content type to:
@@ -16,18 +22,47 @@ import type { FlushReason } from './flushController'
  * to be parsed correctly without content type header
  */
 
-export type HttpRequest = ReturnType<typeof createHttpRequest>
+export interface HttpRequest<Body extends Payload = Payload> {
+  observable: Observable<HttpRequestEvent<Body>>
+  send(this: void, payload: Body): void
+  sendOnExit(this: void, payload: Body): void
+}
 
 export interface HttpResponse extends Context {
   status: number
   type?: ResponseType
 }
 
+export interface BandwidthStats {
+  ongoingByteCount: number
+  ongoingRequestCount: number
+}
+
+export type HttpRequestEvent<Body extends Payload = Payload> =
+  | {
+      // A request to send the given payload failed. (We may retry.)
+      type: 'failure'
+      bandwidth: BandwidthStats
+      payload: Body
+    }
+  | {
+      // The given payload was discarded because the request queue is full.
+      type: 'queue-full'
+      bandwidth: BandwidthStats
+      payload: Body
+    }
+  | {
+      // A request to send the given payload succeeded.
+      type: 'success'
+      bandwidth: BandwidthStats
+      payload: Body
+    }
+
 export interface Payload {
-  data: string | FormData
+  data: string | FormData | Blob
   bytesCount: number
   retry?: RetryInfo
-  flushReason?: FlushReason
+  encoding?: 'deflate'
 }
 
 export interface RetryInfo {
@@ -35,41 +70,52 @@ export interface RetryInfo {
   lastFailureStatus: number
 }
 
-export function createHttpRequest(
-  configuration: Configuration,
-  endpointBuilder: EndpointBuilder,
-  bytesLimit: number,
-  reportError: (error: RawError) => void
-) {
-  const retryState = newRetryState()
-  const sendStrategyForRetry = (payload: Payload, onResponse: (r: HttpResponse) => void) =>
-    fetchKeepAliveStrategy(configuration, endpointBuilder, bytesLimit, payload, onResponse)
+export function createHttpRequest<Body extends Payload = Payload>(
+  endpointBuilders: EndpointBuilder[],
+  reportError: (error: RawError) => void,
+  bytesLimit: number = RECOMMENDED_REQUEST_BYTES_LIMIT
+): HttpRequest<Body> {
+  const observable = new Observable<HttpRequestEvent<Body>>()
+  const retryState = newRetryState<Body>()
 
   return {
-    send: (payload: Payload) => {
-      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.endpointType, reportError)
+    observable,
+    send: (payload: Body) => {
+      for (const endpointBuilder of endpointBuilders) {
+        sendWithRetryStrategy(
+          payload,
+          retryState,
+          (payload, onResponse) => {
+            if (isExperimentalFeatureEnabled(ExperimentalFeature.AVOID_FETCH_KEEPALIVE)) {
+              fetchStrategy(endpointBuilder, payload, onResponse)
+            } else {
+              fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse)
+            }
+          },
+          endpointBuilder.trackType,
+          reportError,
+          observable
+        )
+      }
     },
     /**
      * Since fetch keepalive behaves like regular fetch on Firefox,
      * keep using sendBeaconStrategy on exit
      */
-    sendOnExit: (payload: Payload) => {
-      sendBeaconStrategy(configuration, endpointBuilder, bytesLimit, payload)
+    sendOnExit: (payload: Body) => {
+      for (const endpointBuilder of endpointBuilders) {
+        sendBeaconStrategy(endpointBuilder, bytesLimit, payload)
+      }
     },
   }
 }
 
-function sendBeaconStrategy(
-  configuration: Configuration,
-  endpointBuilder: EndpointBuilder,
-  bytesLimit: number,
-  { data, bytesCount, flushReason }: Payload
-) {
-  const canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit
+function sendBeaconStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload) {
+  const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit
   if (canUseBeacon) {
     try {
-      const beaconUrl = endpointBuilder.build('beacon', flushReason)
-      const isQueued = navigator.sendBeacon(beaconUrl, data)
+      const beaconUrl = endpointBuilder.build('beacon', payload)
+      const isQueued = navigator.sendBeacon(beaconUrl, payload.data)
 
       if (isQueued) {
         return
@@ -79,8 +125,7 @@ function sendBeaconStrategy(
     }
   }
 
-  const xhrUrl = endpointBuilder.build('xhr', flushReason)
-  sendXHR(configuration, xhrUrl, data)
+  fetchStrategy(endpointBuilder, payload)
 }
 
 let hasReportedBeaconError = false
@@ -88,34 +133,41 @@ let hasReportedBeaconError = false
 function reportBeaconError(e: unknown) {
   if (!hasReportedBeaconError) {
     hasReportedBeaconError = true
-    addTelemetryError(e)
+    monitorError(e)
   }
 }
 
 export function fetchKeepAliveStrategy(
-  configuration: Configuration,
   endpointBuilder: EndpointBuilder,
   bytesLimit: number,
-  { data, bytesCount, flushReason, retry }: Payload,
+  payload: Payload,
   onResponse?: (r: HttpResponse) => void
 ) {
-  const canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit
+  const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit
+
   if (canUseKeepAlive) {
-    const fetchUrl = endpointBuilder.build('fetch', flushReason, retry)
-    fetch(fetchUrl, { method: 'POST', body: data, keepalive: true, mode: 'cors' }).then(
-      monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })),
-      monitor(() => {
-        const xhrUrl = endpointBuilder.build('xhr', flushReason, retry)
-        // failed to queue the request
-        sendXHR(configuration, xhrUrl, data, onResponse)
-      })
-    )
+    const fetchUrl = endpointBuilder.build('fetch-keepalive', payload)
+
+    fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' })
+      .then(monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })))
+      .catch(monitor(() => fetchStrategy(endpointBuilder, payload, onResponse)))
   } else {
-    const xhrUrl = endpointBuilder.build('xhr', flushReason, retry)
-    sendXHR(configuration, xhrUrl, data, onResponse)
+    fetchStrategy(endpointBuilder, payload, onResponse)
   }
 }
 
+export function fetchStrategy(
+  endpointBuilder: EndpointBuilder,
+  payload: Payload,
+  onResponse?: (r: HttpResponse) => void
+) {
+  const fetchUrl = endpointBuilder.build('fetch', payload)
+
+  fetch(fetchUrl, { method: 'POST', body: payload.data, mode: 'cors' })
+    .then(monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })))
+    .catch(monitor(() => onResponse?.({ status: 0 })))
+}
+
 function isKeepAliveSupported() {
   // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors
   try {
@@ -124,27 +176,3 @@ function isKeepAliveSupported() {
     return false
   }
 }
-
-export function sendXHR(
-  configuration: Configuration,
-  url: string,
-  data: Payload['data'],
-  onResponse?: (r: HttpResponse) => void
-) {
-  const request = new XMLHttpRequest()
-  request.open('POST', url, true)
-  addEventListener(
-    configuration,
-    request,
-    'loadend',
-    () => {
-      onResponse?.({ status: request.status })
-    },
-    {
-      // prevent multiple onResponse callbacks
-      // if the xhr instance is reused by a third party
-      once: true,
-    }
-  )
-  request.send(data)
-}

package/src/transport/index.ts

@@ -1,4 +1,7 @@
-export { HttpRequest, createHttpRequest, Payload, RetryInfo } from './httpRequest'
-export { canUseEventBridge, getEventBridge, BrowserWindowWithEventBridge } from './eventBridge'
-export { startBatchWithReplica } from './startBatchWithReplica'
-export { createFlushController, FlushController, FlushEvent, FlushReason } from './flushController'
+export type { BandwidthStats, HttpRequest, HttpRequestEvent, Payload, RetryInfo } from './httpRequest'
+export { createHttpRequest } from './httpRequest'
+export type { BrowserWindowWithEventBridge, DatadogEventBridge } from './eventBridge'
+export { canUseEventBridge, bridgeSupports, getEventBridge, BridgeCapability } from './eventBridge'
+export { createBatch } from './batch'
+export type { FlushController, FlushEvent, FlushReason } from './flushController'
+export { createFlushController, FLUSH_DURATION_LIMIT } from './flushController'