@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/tools/utils/stringUtils.ts

@@ -9,7 +9,10 @@ export function generateUUID(placeholder?: string): string {
     : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID)
 }
 
-const COMMA_SEPARATED_KEY_VALUE = /([\w-]+)\s*=\s*([^;]+)/g
+// Assuming input string is following the HTTP Cookie format defined in
+// https://www.ietf.org/rfc/rfc2616.txt and https://www.ietf.org/rfc/rfc6265.txt, we don't need to
+// be too strict with this regex.
+const COMMA_SEPARATED_KEY_VALUE = /(\S+?)\s*=\s*(.*?)(?:;|$)/g
 
 /**
  * Returns the value of the key with the given name
@@ -84,3 +87,22 @@ export function safeTruncate(candidate: string, length: number, suffix = '') {
 
   return `${candidate.slice(0, correctedLength)}${suffix}`
 }
+
+/**
+ * Builds a telemetry integration identifier from a library name and its version, e.g. `react-v18`
+ */
+export function toMajorVersionIntegration(name: string, version: string | null | undefined): string {
+  if (!version) {
+    return name
+  }
+  return `${name}-v${version.split('.')[0]}`
+}
+
+/**
+ * Filters out falsy values and returns `undefined` if no integration is left, so plugins report a
+ * consistent "nothing to report" telemetry shape instead of an empty array.
+ */
+export function toIntegrations(...maybeIntegrations: Array<string | false | undefined>): string[] | undefined {
+  const integrations = maybeIntegrations.filter((integration): integration is string => !!integration)
+  return integrations.length > 0 ? integrations : undefined
+}

package/src/tools/valueHistory.ts

@@ -1,8 +1,8 @@
+import { ONE_MINUTE, addDuration, relativeNow } from '@kubesense/kubesense-js-core/time'
+import type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time'
 import { setInterval, clearInterval } from './timer'
 import type { TimeoutId } from './timer'
 import { removeItem } from './utils/arrayUtils'
-import type { Duration, RelativeTime } from './utils/timeUtils'
-import { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils'
 
 const END_OF_TIMES = Infinity as RelativeTime
 
@@ -26,11 +26,13 @@ export interface ValueHistory<Value> {
 
   closeActive: (endTime: RelativeTime) => void
   findAll: (startTime?: RelativeTime, duration?: Duration) => Value[]
+  findAllEntries: (startTime?: RelativeTime, duration?: Duration) => Array<ValueHistoryEntry<Value>>
+  getEntries: (startTime: RelativeTime) => Array<ValueHistoryEntry<Value>>
   reset: () => void
   stop: () => void
 }
 
-let cleanupHistoriesInterval: TimeoutId | null = null
+let cleanupHistoriesInterval: TimeoutId | undefined
 
 const cleanupTasks: Set<() => void> = new Set()
 
@@ -38,27 +40,35 @@ function cleanupHistories() {
   cleanupTasks.forEach((task) => task())
 }
 
-export function createValueHistory<Value>({
-  expireDelay,
-  maxEntries,
-}: {
-  expireDelay: number
-  maxEntries?: number
-}): ValueHistory<Value> {
-  let entries: Array<ValueHistoryEntry<Value>> = []
+type ValueHistoryArgs =
+  | {
+      expireDelay?: number
+      maxEntries: number
+    }
+  | {
+      expireDelay: number
+      maxEntries?: number
+    }
 
-  if (!cleanupHistoriesInterval) {
-    cleanupHistoriesInterval = setInterval(() => cleanupHistories(), CLEAR_OLD_VALUES_INTERVAL)
-  }
+export function createValueHistory<Value>({ expireDelay, maxEntries }: ValueHistoryArgs): ValueHistory<Value> {
+  let entries: Array<ValueHistoryEntry<Value>> = []
 
   const clearExpiredValues = () => {
+    if (!expireDelay) {
+      return
+    }
     const oldTimeThreshold = relativeNow() - expireDelay
     while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {
       entries.pop()
     }
   }
 
-  cleanupTasks.add(clearExpiredValues)
+  if (expireDelay) {
+    if (!cleanupHistoriesInterval) {
+      cleanupHistoriesInterval = setInterval(() => cleanupHistories(), CLEAR_OLD_VALUES_INTERVAL)
+    }
+    cleanupTasks.add(clearExpiredValues)
+  }
 
   /**
    * Add a value to the history associated with a start time. Returns a reference to this newly
@@ -112,7 +122,7 @@ export function createValueHistory<Value>({
    */
   function closeActive(endTime: RelativeTime) {
     const latestEntry = entries[0]
-    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
+    if (latestEntry?.endTime === END_OF_TIMES) {
       latestEntry.close(endTime)
     }
   }
@@ -129,6 +139,26 @@ export function createValueHistory<Value>({
       .map((entry) => entry.value)
   }
 
+  /**
+   * Return all entries with an active period overlapping with the duration,
+   * or all entries that were active during `startTime` if no duration is provided,
+   * or all currently active entries if no `startTime` is provided.
+   */
+  function findAllEntries(
+    startTime: RelativeTime = END_OF_TIMES,
+    duration = 0 as Duration
+  ): Array<ValueHistoryEntry<Value>> {
+    const endTime = addDuration(startTime, duration)
+    return entries.filter((entry) => entry.startTime <= endTime && startTime <= entry.endTime)
+  }
+
+  /**
+   * Return all the entries whose start time is equal to the given startTime.
+   */
+  function getEntries(startTime: RelativeTime): Array<ValueHistoryEntry<Value>> {
+    return entries.filter((entry) => entry.startTime === startTime)
+  }
+
   /**
    * Remove all entries from this collection.
    */
@@ -143,9 +173,20 @@ export function createValueHistory<Value>({
     cleanupTasks.delete(clearExpiredValues)
     if (cleanupTasks.size === 0 && cleanupHistoriesInterval) {
       clearInterval(cleanupHistoriesInterval)
-      cleanupHistoriesInterval = null
+      cleanupHistoriesInterval = undefined
     }
   }
 
-  return { add, find, closeActive, findAll, reset, stop }
+  return { add, find, closeActive, findAll, findAllEntries, getEntries, reset, stop }
+}
+
+/**
+ * Reset all global state. This is useful for testing to ensure clean state between tests.
+ *
+ * @internal
+ */
+export function resetValueHistoryGlobals() {
+  cleanupTasks.clear()
+  clearInterval(cleanupHistoriesInterval)
+  cleanupHistoriesInterval = undefined
 }

package/src/transport/batch.ts

@@ -1,58 +1,73 @@
-import { DOCS_TROUBLESHOOTING, MORE_DETAILS, display } from '../tools/display'
+import type { EndpointBuilder } from '@kubesense/kubesense-js-core/transport'
+import { MORE_DETAILS } from '@kubesense/kubesense-js-core/util'
+import { DOCS_TROUBLESHOOTING, display } from '../tools/display'
 import type { Context } from '../tools/serialisation/context'
 import { objectValues } from '../tools/utils/polyfills'
-import { isPageExitReason } from '../browser/pageMayExitObservable'
+import { isPageExitReason, createPageMayExitObservable } from '../browser/pageMayExitObservable'
 import { jsonStringify } from '../tools/serialisation/jsonStringify'
+import { createIdentityEncoder } from '../tools/encoder'
 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'
+import { mockable } from '../tools/mockable'
+import type { Observable } from '../tools/observable'
+import { createHttpRequest } from './httpRequest'
+import type { Payload } from './httpRequest'
+import { createFlushController } from './flushController'
+import type { FlushEvent, FlushReason, UrgentFlushReason } from './flushController'
 
 export const MESSAGE_BYTES_LIMIT = 256 * ONE_KIBI_BYTE
 
 export interface Batch {
-  flushController: FlushController
+  isEmpty: boolean
   add: (message: Context) => void
   upsert: (message: Context, key: string) => void
+  forceFlush: (reason: FlushReason) => void
+  prepareUrgentFlushObservable: Observable<UrgentFlushReason>
+  flushObservable: Observable<FlushEvent>
   stop: () => void
 }
 
 export function createBatch({
-  encoder,
-  request,
-  flushController,
+  encoder = createIdentityEncoder(),
+  endpoints,
+  reportError,
 }: {
-  encoder: Encoder
-  request: HttpRequest
-  flushController: FlushController
+  encoder?: Encoder
+  endpoints: EndpointBuilder[]
+  reportError: (message: string) => void
 }): Batch {
+  const request = mockable(createHttpRequest)(endpoints, reportError)
+  const pageMayExitObservable = mockable(createPageMayExitObservable)()
+  const flushController = mockable(createFlushController)({ pageMayExitObservable })
   let upsertBuffer: { [key: string]: string } = {}
   const flushSubscription = flushController.flushObservable.subscribe((event) => flush(event))
 
-  function push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {
-    flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
+  // A batch that failed in transit sits in the retry queue with its view counters already
+  // incremented. Draining it with sendBeacon on page exit is the last chance to deliver it, and
+  // without this the counters on the view event would not match the events the backend received.
+  const pageExitSubscription = pageMayExitObservable.subscribe(() => {
+    request.sendQueuedOnExit()
+  })
 
+  function push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {
     if (key !== undefined) {
+      let bytesDiff: number
+      if (upsertBuffer[key] !== undefined) {
+        bytesDiff = estimatedMessageBytesCount - encoder.estimateEncodedBytesCount(upsertBuffer[key])
+      } else {
+        flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
+        bytesDiff = 0
+      }
       upsertBuffer[key] = serializedMessage
-      flushController.notifyAfterAddMessage()
+      flushController.notifyAfterAddMessage(bytesDiff)
     } else {
+      flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
       encoder.write(encoder.isEmpty ? serializedMessage : `\n${serializedMessage}`, (realMessageBytesCount) => {
         flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)
       })
     }
   }
 
-  function hasMessageFor(key?: string): key is string {
-    return key !== undefined && upsertBuffer[key] !== undefined
-  }
-
-  function remove(key: string) {
-    const removedMessage = upsertBuffer[key]
-    delete upsertBuffer[key]
-    const messageBytesCount = encoder.estimateEncodedBytesCount(removedMessage)
-    flushController.notifyAfterRemoveMessage(messageBytesCount)
-  }
-
   function addOrUpdate(message: Context, key?: string) {
     const serializedMessage = jsonStringify(message)!
 
@@ -65,10 +80,6 @@ export function createBatch({
       return
     }
 
-    if (hasMessageFor(key)) {
-      remove(key)
-    }
-
     push(serializedMessage, estimatedMessageBytesCount, key)
   }
 
@@ -113,10 +124,18 @@ export function createBatch({
   }
 
   return {
-    flushController,
+    get isEmpty() {
+      return flushController.messagesCount === 0
+    },
     add: addOrUpdate,
     upsert: addOrUpdate,
-    stop: flushSubscription.unsubscribe,
+    prepareUrgentFlushObservable: flushController.prepareUrgentFlushObservable,
+    forceFlush: flushController.forceFlush,
+    flushObservable: flushController.flushObservable,
+    stop: () => {
+      flushSubscription.unsubscribe()
+      pageExitSubscription.unsubscribe()
+    },
   }
 }
 

package/src/transport/eventBridge.ts

@@ -1,19 +1,22 @@
-import { getGlobalObject } from '../tools/globalObject'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { display } from '../tools/display'
 import type { DefaultPrivacyLevel } from '../domain/configuration'
 
-export interface BrowserWindowWithEventBridge extends Window {
+export interface BrowserWindowWithEventBridge {
   KubeSenseEventBridge?: KubeSenseEventBridge
 }
 
 export interface KubeSenseEventBridge {
   getCapabilities?(): string
   getPrivacyLevel?(): DefaultPrivacyLevel
+  getIsTraceSampled?(): 'true' | 'false' | 'null'
   getAllowedWebViewHosts(): string
   send(msg: string): void
 }
 
 export const enum BridgeCapability {
   RECORDS = 'records',
+  PROFILES = 'profiles',
 }
 
 export function getEventBridge<T, E>() {
@@ -30,6 +33,9 @@ export function getEventBridge<T, E>() {
     getPrivacyLevel() {
       return eventBridgeGlobal.getPrivacyLevel?.()
     },
+    getIsTraceSampled() {
+      return JSON.parse(eventBridgeGlobal.getIsTraceSampled?.() || 'null') as boolean | null
+    },
     getAllowedWebViewHosts() {
       return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts()) as string[]
     },
@@ -45,16 +51,24 @@ export function bridgeSupports(capability: BridgeCapability): boolean {
   return !!bridge && bridge.getCapabilities().includes(capability)
 }
 
-export function canUseEventBridge(currentHost = getGlobalObject<Window>().location?.hostname): boolean {
+export function canUseEventBridge(currentHost = globalObject.location?.hostname): boolean {
   const bridge = getEventBridge()
-  return (
-    !!bridge &&
-    bridge
-      .getAllowedWebViewHosts()
-      .some((allowedHost) => currentHost === allowedHost || currentHost.endsWith(`.${allowedHost}`))
-  )
+  return bridge?.getAllowedWebViewHosts().some((entry) => matchesHostEntry(currentHost, entry)) ?? false
+}
+
+export function matchesHostEntry(host: string, entry: string): boolean {
+  if (!entry.includes('*')) {
+    return host === entry || host.endsWith(`.${entry}`)
+  }
+  const parts = entry.split('*')
+  if (parts.length !== 2) {
+    display.error(`Invalid WebView host pattern "${entry}": only one wildcard (*) is supported.`)
+    return false
+  }
+  const [prefix, suffix] = parts
+  return host.length > prefix.length + suffix.length && host.startsWith(prefix) && host.endsWith(suffix)
 }
 
 function getEventBridgeGlobal() {
-  return getGlobalObject<BrowserWindowWithEventBridge>().KubeSenseEventBridge
+  return (globalObject as BrowserWindowWithEventBridge).KubeSenseEventBridge
 }

package/src/transport/flushController.ts

@@ -1,13 +1,14 @@
+import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'
+import type { Duration } from '@kubesense/kubesense-js-core/time'
+import { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
 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'
+export type UrgentFlushReason = PageExitReason
+export type FlushReason = UrgentFlushReason | 'duration_limit' | 'bytes_limit' | 'messages_limit' | 'session_expire'
 
 /**
  * flush automatically, aim to be lower than ALB connection timeout
@@ -30,7 +31,6 @@ export interface FlushEvent {
 
 interface FlushControllerOptions {
   pageMayExitObservable: Observable<PageMayExitEvent>
-  sessionExpireObservable: Observable<void>
 }
 
 /**
@@ -38,13 +38,21 @@ 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({ pageMayExitObservable, sessionExpireObservable }: FlushControllerOptions) {
-  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => flush(event.reason))
-  const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'))
+export function createFlushController({ pageMayExitObservable }: FlushControllerOptions) {
+  let forcedFlushReason: FlushReason | undefined
+  const prepareUrgentFlushObservable = new Observable<UrgentFlushReason>()
+  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
+    forcedFlushReason = event.reason
+    try {
+      prepareUrgentFlushObservable.notify(event.reason)
+    } finally {
+      forcedFlushReason = undefined
+    }
+    flush(event.reason)
+  })
 
   const flushObservable = new Observable<FlushEvent>(() => () => {
     pageMayExitSubscription.unsubscribe()
-    sessionExpireSubscription.unsubscribe()
   })
 
   let currentBytesCount = 0
@@ -85,6 +93,8 @@ export function createFlushController({ pageMayExitObservable, sessionExpireObse
 
   return {
     flushObservable,
+    prepareUrgentFlushObservable,
+    forceFlush: flush,
     get messagesCount() {
       return currentMessagesCount
     },
@@ -100,7 +110,7 @@ export function createFlushController({ pageMayExitObservable, sessionExpireObse
      */
     notifyBeforeAddMessage(estimatedMessageBytesCount: number) {
       if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {
-        flush('bytes_limit')
+        flush(forcedFlushReason ?? '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
@@ -123,27 +133,9 @@ export function createFlushController({ pageMayExitObservable, sessionExpireObse
       currentBytesCount += messageBytesCountDiff
 
       if (currentMessagesCount >= MESSAGES_LIMIT) {
-        flush('messages_limit')
+        flush(forcedFlushReason ?? 'messages_limit')
       } else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {
-        flush('bytes_limit')
-      }
-    },
-
-    /**
-     * Notifies that a message was removed from a pool of pending messages waiting to be flushed.
-     *
-     * 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
-      currentMessagesCount -= 1
-      if (currentMessagesCount === 0) {
-        cancelDurationLimitTimeout()
+        flush(forcedFlushReason ?? 'bytes_limit')
       }
     },
   }

package/src/transport/httpRequest.ts

@@ -1,8 +1,7 @@
-import type { EndpointBuilder } from '../domain/configuration'
+import type { EndpointBuilder, TransportRetryInfo } from '@kubesense/kubesense-js-core/transport'
+import { monitor, monitorError } from '@kubesense/kubesense-js-core/monitor'
 import type { Context } from '../tools/serialisation/context'
-import { monitor, monitorError } from '../tools/monitor'
-import type { RawError } from '../domain/error/error.types'
-import { isExperimentalFeatureEnabled, ExperimentalFeature } from '../tools/experimentalFeatures'
+import { fetch } from '../browser/fetch'
 import { Observable } from '../tools/observable'
 import { ONE_KIBI_BYTE } from '../tools/utils/byteUtils'
 import { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'
@@ -58,26 +57,30 @@ export type HttpRequestEvent<Body extends Payload = Payload> =
       bandwidth: BandwidthStats
       payload: Body
     }
+  | {
+      // A request to send the given payload failed and will not be retried; the payload is gone.
+      // `status` is the last response's, 0 for a network error.
+      type: 'dropped'
+      bandwidth: BandwidthStats
+      payload: Body
+      status: number
+    }
 
 export interface Payload {
   data: string | FormData | Blob
   bytesCount: number
-  retry?: RetryInfo
+  retry?: TransportRetryInfo
   encoding?: 'deflate'
 }
 
-export interface RetryInfo {
-  count: number
-  lastFailureStatus: number
-}
-
 export function createHttpRequest<Body extends Payload = Payload>(
   endpointBuilders: EndpointBuilder[],
-  reportError: (error: RawError) => void,
-  bytesLimit: number = RECOMMENDED_REQUEST_BYTES_LIMIT
+  reportError: (message: string) => void,
+  bytesLimit: number = RECOMMENDED_REQUEST_BYTES_LIMIT,
+  networkErrorRetries = 0
 ): HttpRequest<Body> {
   const observable = new Observable<HttpRequestEvent<Body>>()
-  const retryState = newRetryState<Body>()
+  const retryState = newRetryState<Body>(networkErrorRetries)
 
   return {
     observable,
@@ -87,11 +90,7 @@ export function createHttpRequest<Body extends Payload = Payload>(
           payload,
           retryState,
           (payload, onResponse) => {
-            if (isExperimentalFeatureEnabled(ExperimentalFeature.AVOID_FETCH_KEEPALIVE)) {
-              fetchStrategy(endpointBuilder, payload, onResponse)
-            } else {
-              fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse)
-            }
+            fetchStrategy(endpointBuilder, payload, onResponse)
           },
           endpointBuilder.trackType,
           reportError,
@@ -124,7 +123,7 @@ export function createHttpRequest<Body extends Payload = Payload>(
 }
 
 function sendBeaconStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload) {
-  const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit
+  const canUseBeacon = payload.bytesCount < bytesLimit
   if (canUseBeacon) {
     try {
       const beaconUrl = endpointBuilder.build('beacon', payload)
@@ -150,25 +149,6 @@ function reportBeaconError(e: unknown) {
   }
 }
 
-export function fetchKeepAliveStrategy(
-  endpointBuilder: EndpointBuilder,
-  bytesLimit: number,
-  payload: Payload,
-  onResponse?: (r: HttpResponse) => void
-) {
-  const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit
-
-  if (canUseKeepAlive) {
-    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 {
-    fetchStrategy(endpointBuilder, payload, onResponse)
-  }
-}
-
 export function fetchStrategy(
   endpointBuilder: EndpointBuilder,
   payload: Payload,
@@ -180,12 +160,3 @@ export function fetchStrategy(
     .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 {
-    return window.Request && 'keepalive' in new Request('http://a')
-  } catch {
-    return false
-  }
-}

package/src/transport/index.ts

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