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

package/src/transport/batch.ts

@@ -1,59 +1,97 @@
-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 { isPageExitReason } from '../browser/pageMayExitObservable'
 import { jsonStringify } from '../tools/serialisation/jsonStringify'
-import type { Subscription } from '../tools/observable'
 import type { Encoder, EncoderResult } from '../tools/encoder'
-import { computeBytesCount } from '../tools/utils/byteUtils'
+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 upsertBuffer: { [key: string]: string } = {}
-  private flushSubscription: Subscription
-
-  constructor(
-    private encoder: Encoder,
-    private request: HttpRequest,
-    public flushController: FlushController,
-    private messageBytesLimit: number
-  ) {
-    this.flushSubscription = this.flushController.flushObservable.subscribe((event) => this.flush(event))
+export const MESSAGE_BYTES_LIMIT = 256 * ONE_KIBI_BYTE
+
+export interface Batch {
+  flushController: FlushController
+  add: (message: Context) => void
+  upsert: (message: Context, key: string) => void
+  stop: () => void
+}
+
+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)
+
+    if (key !== undefined) {
+      upsertBuffer[key] = serializedMessage
+      flushController.notifyAfterAddMessage()
+    } else {
+      encoder.write(encoder.isEmpty ? serializedMessage : `\n${serializedMessage}`, (realMessageBytesCount) => {
+        flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)
+      })
+    }
   }
 
-  add(message: Context) {
-    this.addOrUpdate(message)
+  function hasMessageFor(key?: string): key is string {
+    return key !== undefined && upsertBuffer[key] !== undefined
   }
 
-  upsert(message: Context, key: string) {
-    this.addOrUpdate(message, key)
+  function remove(key: string) {
+    const removedMessage = upsertBuffer[key]
+    delete upsertBuffer[key]
+    const messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage)
+    flushController.notifyAfterRemoveMessage(messageBytesCount)
   }
 
-  stop() {
-    this.flushSubscription.unsubscribe()
+  function addOrUpdate(message: Context, key?: string) {
+    const serializedMessage = jsonStringify(message)!
+
+    const estimatedMessageBytesCount = encoder.estimateEncodedBytesCount(serializedMessage)
+
+    if (estimatedMessageBytesCount >= MESSAGE_BYTES_LIMIT) {
+      display.warn(
+        `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 (hasMessageFor(key)) {
+      remove(key)
+    }
+
+    push(serializedMessage, estimatedMessageBytesCount, key)
   }
 
-  private flush(event: FlushEvent) {
-    const upsertMessages = objectValues(this.upsertBuffer).join('\n')
-    this.upsertBuffer = {}
+  function flush(event: FlushEvent) {
+    const upsertMessages = objectValues(upsertBuffer).join('\n')
+    upsertBuffer = {}
 
-    const isPageExit = isPageExitReason(event.reason)
-    const send = isPageExit ? this.request.sendOnExit : this.request.send
+    const pageMightExit = isPageExitReason(event.reason)
+    const send = pageMightExit ? request.sendOnExit : request.send
 
     if (
-      isPageExit &&
+      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.
-      this.encoder.isAsync
+      encoder.isAsync
     ) {
-      const encoderResult = this.encoder.finishSync()
+      const encoderResult = encoder.finishSync()
 
       // Send encoded messages
       if (encoderResult.outputBytesCount) {
-        send(formatPayloadFromEncoder(encoderResult, event))
+        send(formatPayloadFromEncoder(encoderResult))
       }
 
       // Send messages that are not yet encoded at this point
@@ -62,67 +100,27 @@ export class Batch {
         send({
           data: pendingMessages,
           bytesCount: computeBytesCount(pendingMessages),
-          flushReason: event.reason,
         })
       }
     } else {
       if (upsertMessages) {
-        this.encoder.write(this.encoder.isEmpty ? upsertMessages : `\n${upsertMessages}`)
+        encoder.write(encoder.isEmpty ? upsertMessages : `\n${upsertMessages}`)
       }
-      this.encoder.finish((encoderResult) => {
-        send(formatPayloadFromEncoder(encoderResult, event))
+      encoder.finish((encoderResult) => {
+        send(formatPayloadFromEncoder(encoderResult))
       })
     }
   }
 
-  private addOrUpdate(message: Context, key?: string) {
-    const serializedMessage = jsonStringify(message)!
-
-    const estimatedMessageBytesCount = this.encoder.estimateEncodedBytesCount(serializedMessage)
-
-    if (estimatedMessageBytesCount >= this.messageBytesLimit) {
-      display.warn(
-        `Discarded a message whose size was bigger than the maximum allowed size ${this.messageBytesLimit}KB.`
-      )
-      return
-    }
-
-    if (this.hasMessageFor(key)) {
-      this.remove(key)
-    }
-
-    this.push(serializedMessage, estimatedMessageBytesCount, key)
-  }
-
-  private push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {
-    this.flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
-
-    if (key !== undefined) {
-      this.upsertBuffer[key] = serializedMessage
-      this.flushController.notifyAfterAddMessage()
-    } else {
-      this.encoder.write(
-        this.encoder.isEmpty ? serializedMessage : `\n${serializedMessage}`,
-        (realMessageBytesCount) => {
-          this.flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)
-        }
-      )
-    }
-  }
-
-  private remove(key: string) {
-    const removedMessage = this.upsertBuffer[key]
-    delete this.upsertBuffer[key]
-    const messageBytesCount = this.encoder.estimateEncodedBytesCount(removedMessage)
-    this.flushController.notifyAfterRemoveMessage(messageBytesCount)
-  }
-
-  private hasMessageFor(key?: string): key is string {
-    return key !== undefined && this.upsertBuffer[key] !== undefined
+  return {
+    flushController,
+    add: addOrUpdate,
+    upsert: addOrUpdate,
+    stop: flushSubscription.unsubscribe,
   }
 }
 
-function formatPayloadFromEncoder(encoderResult: EncoderResult, flushEvent: FlushEvent): Payload {
+function formatPayloadFromEncoder(encoderResult: EncoderResult): Payload {
   let data: string | Blob
   if (typeof encoderResult.output === 'string') {
     data = encoderResult.output
@@ -142,6 +140,5 @@ function formatPayloadFromEncoder(encoderResult: EncoderResult, flushEvent: Flus
     data,
     bytesCount: encoderResult.outputBytesCount,
     encoding: encoderResult.encoding,
-    flushReason: flushEvent.reason,
   }
 }

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,18 +38,12 @@ 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 pageExitSubscription = pageExitObservable.subscribe((event) => flush(event.reason))
+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>(() => () => {
-    pageExitSubscription.unsubscribe()
+    pageMayExitSubscription.unsubscribe()
     sessionExpireSubscription.unsubscribe()
   })
 
@@ -68,7 +74,7 @@ export function createFlushController({
     if (durationLimitTimeoutId === undefined) {
       durationLimitTimeoutId = setTimeout(() => {
         flush('duration_limit')
-      }, durationLimit)
+      }, FLUSH_DURATION_LIMIT)
     }
   }
 
@@ -89,11 +95,11 @@ 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
+     * @param estimatedMessageBytesCount - an estimation of the message bytes count once it is
      * actually added.
      */
     notifyBeforeAddMessage(estimatedMessageBytesCount: number) {
-      if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {
+      if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {
         flush('bytes_limit')
       }
       // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no
@@ -110,15 +116,15 @@ 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
+     * @param messageBytesCountDiff - the difference between the estimated message bytes count and
      * its actual bytes count once added to the pool.
      */
     notifyAfterAddMessage(messageBytesCountDiff = 0) {
       currentBytesCount += messageBytesCountDiff
 
-      if (currentMessagesCount >= messagesLimit) {
+      if (currentMessagesCount >= MESSAGES_LIMIT) {
         flush('messages_limit')
-      } else if (currentBytesCount >= bytesLimit) {
+      } else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {
         flush('bytes_limit')
       }
     },
@@ -129,7 +135,7 @@ 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
+     * @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`.
      */

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,46 @@ 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 | Blob
   bytesCount: number
   retry?: RetryInfo
-  flushReason?: FlushReason
   encoding?: 'deflate'
 }
 
@@ -36,36 +70,47 @@ 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.trackType, 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,
-  payload: Payload
-) {
+function sendBeaconStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload) {
   const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit
   if (canUseBeacon) {
     try {
@@ -80,8 +125,7 @@ function sendBeaconStrategy(
     }
   }
 
-  const xhrUrl = endpointBuilder.build('xhr', payload)
-  sendXHR(configuration, xhrUrl, payload.data)
+  fetchStrategy(endpointBuilder, payload)
 }
 
 let hasReportedBeaconError = false
@@ -89,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,
   payload: Payload,
   onResponse?: (r: HttpResponse) => void
 ) {
   const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit
+
   if (canUseKeepAlive) {
-    const fetchUrl = endpointBuilder.build('fetch', payload)
-    fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(
-      monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })),
-      monitor(() => {
-        const xhrUrl = endpointBuilder.build('xhr', payload)
-        // failed to queue the request
-        sendXHR(configuration, xhrUrl, payload.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', payload)
-    sendXHR(configuration, xhrUrl, payload.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 {
@@ -125,33 +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)
-  if (data instanceof Blob) {
-    // When using a Blob instance, IE does not use its 'type' to define the 'Content-Type' header
-    // automatically, so the intake request ends up being rejected with an HTTP status 415
-    // Defining the header manually fixes this issue.
-    request.setRequestHeader('Content-Type', data.type)
-  }
-  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'