@kubesense/kubesense-browser-core 1.0.0

package/src/tools/utils/timeUtils.ts

@@ -0,0 +1,117 @@
+import { isNumber, round } from './numberUtils'
+
+export const ONE_SECOND = 1000
+export const ONE_MINUTE = 60 * ONE_SECOND
+export const ONE_HOUR = 60 * ONE_MINUTE
+export const ONE_DAY = 24 * ONE_HOUR
+export const ONE_YEAR = 365 * ONE_DAY
+
+export type Duration = number & { d: 'Duration in ms' }
+export type ServerDuration = number & { s: 'Duration in ns' }
+export type TimeStamp = number & { t: 'Epoch time' }
+export type RelativeTime = number & { r: 'Time relative to navigation start' } & { d: 'Duration in ms' }
+export interface ClocksState {
+  relative: RelativeTime
+  timeStamp: TimeStamp
+}
+
+export function relativeToClocks(relative: RelativeTime) {
+  return { relative, timeStamp: getCorrectedTimeStamp(relative) }
+}
+
+export function timeStampToClocks(timeStamp: TimeStamp) {
+  return { relative: getRelativeTime(timeStamp), timeStamp }
+}
+
+function getCorrectedTimeStamp(relativeTime: RelativeTime) {
+  const correctedOrigin = (dateNow() - performance.now()) as TimeStamp
+  // apply correction only for positive drift
+  if (correctedOrigin > getNavigationStart()) {
+    return Math.round(addDuration(correctedOrigin, relativeTime)) as TimeStamp
+  }
+  return getTimeStamp(relativeTime)
+}
+
+export function currentDrift() {
+  return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now() as Duration))
+}
+
+export function toServerDuration(duration: Duration): ServerDuration
+export function toServerDuration(duration: Duration | undefined): ServerDuration | undefined
+export function toServerDuration(duration: Duration | undefined) {
+  if (!isNumber(duration)) {
+    return duration
+  }
+  return round(duration * 1e6, 0) as ServerDuration
+}
+
+export function dateNow() {
+  // Do not use `Date.now` because sometimes websites are wrongly "polyfilling" it. For example, we
+  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date
+  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this
+  // case ourselves.
+  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16
+  return new Date().getTime()
+}
+
+export function timeStampNow() {
+  return dateNow() as TimeStamp
+}
+
+export function relativeNow() {
+  return performance.now() as RelativeTime
+}
+
+export function clocksNow() {
+  return { relative: relativeNow(), timeStamp: timeStampNow() }
+}
+
+export function clocksOrigin() {
+  return { relative: 0 as RelativeTime, timeStamp: getNavigationStart() }
+}
+
+export function elapsed(start: TimeStamp, end: TimeStamp): Duration
+export function elapsed(start: RelativeTime, end: RelativeTime): Duration
+export function elapsed(start: number, end: number) {
+  return (end - start) as Duration
+}
+
+export function addDuration(a: TimeStamp, b: Duration): TimeStamp
+export function addDuration(a: RelativeTime, b: Duration): RelativeTime
+export function addDuration(a: Duration, b: Duration): Duration
+export function addDuration(a: number, b: number) {
+  return a + b
+}
+
+// Get the time since the navigation was started.
+export function getRelativeTime(timestamp: TimeStamp) {
+  return (timestamp - getNavigationStart()) as RelativeTime
+}
+
+export function getTimeStamp(relativeTime: RelativeTime) {
+  return Math.round(addDuration(getNavigationStart(), relativeTime)) as TimeStamp
+}
+
+export function looksLikeRelativeTime(time: RelativeTime | TimeStamp): time is RelativeTime {
+  return time < ONE_YEAR
+}
+
+/**
+ * Navigation start slightly change on some rare cases
+ */
+let navigationStart: TimeStamp | undefined
+
+/**
+ * Notes: this does not use `performance.timeOrigin` because:
+ * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,
+ * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)
+ * - It is not supported in Safari <15
+ */
+function getNavigationStart() {
+  if (navigationStart === undefined) {
+    // ServiceWorkers do not support navigationStart (it's deprecated), so we fallback to timeOrigin
+    navigationStart = (performance.timing?.navigationStart ?? performance.timeOrigin) as TimeStamp
+  }
+  
+  return navigationStart
+}

package/src/tools/utils/timezone.ts

@@ -0,0 +1,9 @@
+export function getTimeZone() {
+  try {
+    const intl = new Intl.DateTimeFormat()
+
+    return intl.resolvedOptions().timeZone
+  } catch {
+    return undefined
+  }
+}

package/src/tools/utils/typeUtils.ts

@@ -0,0 +1,12 @@
+/**
+ * Similar to `typeof`, but distinguish plain objects from `null` and arrays
+ */
+export function getType(value: unknown) {
+  if (value === null) {
+    return 'null'
+  }
+  if (Array.isArray(value)) {
+    return 'array'
+  }
+  return typeof value
+}

package/src/tools/utils/urlPolyfill.ts

@@ -0,0 +1,55 @@
+import { globalObject } from '../globalObject'
+
+export function normalizeUrl(url: string) {
+  return buildUrl(url, location.href).href
+}
+
+export function isValidUrl(url: string) {
+  try {
+    return !!buildUrl(url)
+  } catch {
+    return false
+  }
+}
+
+export function getPathName(url: string) {
+  const pathname = buildUrl(url).pathname
+  return pathname[0] === '/' ? pathname : `/${pathname}`
+}
+
+export function buildUrl(url: string, base?: string) {
+  const { URL } = getPristineWindow()
+
+  try {
+    return base !== undefined ? new URL(url, base) : new URL(url)
+  } catch (error) {
+    throw new Error(`Failed to construct URL: ${String(error)}`)
+  }
+}
+
+/**
+ * Get native URL constructor from a clean iframe
+ * This avoids polyfill issues by getting the native implementation from a fresh iframe context
+ * Falls back to the original URL constructor if iframe approach fails
+ */
+let getPristineGlobalObjectCache: Pick<typeof window, 'URL'> | undefined
+
+export function getPristineWindow() {
+  if (!getPristineGlobalObjectCache) {
+    let iframe: HTMLIFrameElement | undefined
+    let pristineWindow: Window & typeof globalThis
+    try {
+      iframe = document.createElement('iframe')
+      iframe.style.display = 'none'
+      document.body.appendChild(iframe)
+      pristineWindow = iframe.contentWindow as Window & typeof globalThis
+    } catch {
+      pristineWindow = globalObject as unknown as Window & typeof globalThis
+    }
+    getPristineGlobalObjectCache = {
+      URL: pristineWindow.URL,
+    }
+    iframe?.remove()
+  }
+  return getPristineGlobalObjectCache
+}

package/src/tools/valueHistory.ts

@@ -0,0 +1,151 @@
+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
+
+export interface ValueHistoryEntry<T> {
+  startTime: RelativeTime
+  endTime: RelativeTime
+  value: T
+  remove(): void
+  close(endTime: RelativeTime): void
+}
+
+export const CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE
+
+/**
+ * Store and keep track of values spans. This whole cache assumes that values are added in
+ * chronological order (i.e. all entries have an increasing start time).
+ */
+export interface ValueHistory<Value> {
+  add: (value: Value, startTime: RelativeTime) => ValueHistoryEntry<Value>
+  find: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => Value | undefined
+
+  closeActive: (endTime: RelativeTime) => void
+  findAll: (startTime?: RelativeTime, duration?: Duration) => Value[]
+  reset: () => void
+  stop: () => void
+}
+
+let cleanupHistoriesInterval: TimeoutId | null = null
+
+const cleanupTasks: Set<() => void> = new Set()
+
+function cleanupHistories() {
+  cleanupTasks.forEach((task) => task())
+}
+
+export function createValueHistory<Value>({
+  expireDelay,
+  maxEntries,
+}: {
+  expireDelay: number
+  maxEntries?: number
+}): ValueHistory<Value> {
+  let entries: Array<ValueHistoryEntry<Value>> = []
+
+  if (!cleanupHistoriesInterval) {
+    cleanupHistoriesInterval = setInterval(() => cleanupHistories(), CLEAR_OLD_VALUES_INTERVAL)
+  }
+
+  const clearExpiredValues = () => {
+    const oldTimeThreshold = relativeNow() - expireDelay
+    while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {
+      entries.pop()
+    }
+  }
+
+  cleanupTasks.add(clearExpiredValues)
+
+  /**
+   * Add a value to the history associated with a start time. Returns a reference to this newly
+   * added entry that can be removed or closed.
+   */
+  function add(value: Value, startTime: RelativeTime): ValueHistoryEntry<Value> {
+    const entry: ValueHistoryEntry<Value> = {
+      value,
+      startTime,
+      endTime: END_OF_TIMES,
+      remove: () => {
+        removeItem(entries, entry)
+      },
+      close: (endTime: RelativeTime) => {
+        entry.endTime = endTime
+      },
+    }
+
+    if (maxEntries && entries.length >= maxEntries) {
+      entries.pop()
+    }
+
+    entries.unshift(entry)
+
+    return entry
+  }
+
+  /**
+   * Return the latest value that was active during `startTime`, or the currently active value
+   * if no `startTime` is provided. This method assumes that entries are not overlapping.
+   *
+   * If `option.returnInactive` is true, returns the value at `startTime` (active or not).
+   */
+  function find(
+    startTime: RelativeTime = END_OF_TIMES,
+    options: { returnInactive: boolean } = { returnInactive: false }
+  ): Value | undefined {
+    for (const entry of entries) {
+      if (entry.startTime <= startTime) {
+        if (options.returnInactive || startTime <= entry.endTime) {
+          return entry.value
+        }
+        break
+      }
+    }
+  }
+
+  /**
+   * Helper function to close the currently active value, if any. This method assumes that entries
+   * are not overlapping.
+   */
+  function closeActive(endTime: RelativeTime) {
+    const latestEntry = entries[0]
+    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
+      latestEntry.close(endTime)
+    }
+  }
+
+  /**
+   * Return all values with an active period overlapping with the duration,
+   * or all values that were active during `startTime` if no duration is provided,
+   * or all currently active values if no `startTime` is provided.
+   */
+  function findAll(startTime: RelativeTime = END_OF_TIMES, duration = 0 as Duration): Value[] {
+    const endTime = addDuration(startTime, duration)
+    return entries
+      .filter((entry) => entry.startTime <= endTime && startTime <= entry.endTime)
+      .map((entry) => entry.value)
+  }
+
+  /**
+   * Remove all entries from this collection.
+   */
+  function reset() {
+    entries = []
+  }
+
+  /**
+   * Stop internal garbage collection of past entries.
+   */
+  function stop() {
+    cleanupTasks.delete(clearExpiredValues)
+    if (cleanupTasks.size === 0 && cleanupHistoriesInterval) {
+      clearInterval(cleanupHistoriesInterval)
+      cleanupHistoriesInterval = null
+    }
+  }
+
+  return { add, find, closeActive, findAll, reset, stop }
+}

package/src/transport/batch.ts

@@ -0,0 +1,144 @@
+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/pageMayExitObservable'
+import { jsonStringify } from '../tools/serialisation/jsonStringify'
+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 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)
+      })
+    }
+  }
+
+  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)!
+
+    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)
+  }
+
+  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 {
+      if (upsertMessages) {
+        encoder.write(encoder.isEmpty ? upsertMessages : `\n${upsertMessages}`)
+      }
+      encoder.finish((encoderResult) => {
+        send(formatPayloadFromEncoder(encoderResult))
+      })
+    }
+  }
+
+  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',
+    })
+  }
+
+  return {
+    data,
+    bytesCount: encoderResult.outputBytesCount,
+    encoding: encoderResult.encoding,
+  }
+}

package/src/transport/eventBridge.ts

@@ -0,0 +1,60 @@
+import { getGlobalObject } from '../tools/globalObject'
+import type { DefaultPrivacyLevel } from '../domain/configuration'
+
+export interface BrowserWindowWithEventBridge extends Window {
+  KubsesenseEventBridge?: KubsesenseEventBridge
+}
+
+export interface KubsesenseEventBridge {
+  getCapabilities?(): string
+  getPrivacyLevel?(): DefaultPrivacyLevel
+  getAllowedWebViewHosts(): string
+  send(msg: string): void
+}
+
+export const enum BridgeCapability {
+  RECORDS = 'records',
+}
+
+export function getEventBridge<T, E>() {
+  const eventBridgeGlobal = getEventBridgeGlobal()
+
+  if (!eventBridgeGlobal) {
+    return
+  }
+
+  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, 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 || currentHost.endsWith(`.${allowedHost}`))
+  )
+}
+
+function getEventBridgeGlobal() {
+  return getGlobalObject<BrowserWindowWithEventBridge>().KubsesenseEventBridge
+}

package/src/transport/flushController.ts

@@ -0,0 +1,150 @@
+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
+  bytesCount: number
+  messagesCount: number
+}
+
+interface FlushControllerOptions {
+  pageMayExitObservable: Observable<PageMayExitEvent>
+  sessionExpireObservable: Observable<void>
+}
+
+/**
+ * Returns a "flush controller", responsible of notifying when flushing a pool of pending data needs
+ * 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'))
+
+  const flushObservable = new Observable<FlushEvent>(() => () => {
+    pageMayExitSubscription.unsubscribe()
+    sessionExpireSubscription.unsubscribe()
+  })
+
+  let currentBytesCount = 0
+  let currentMessagesCount = 0
+
+  function flush(flushReason: FlushReason) {
+    if (currentMessagesCount === 0) {
+      return
+    }
+
+    const messagesCount = currentMessagesCount
+    const bytesCount = currentBytesCount
+
+    currentMessagesCount = 0
+    currentBytesCount = 0
+    cancelDurationLimitTimeout()
+
+    flushObservable.notify({
+      reason: flushReason,
+      messagesCount,
+      bytesCount,
+    })
+  }
+
+  let durationLimitTimeoutId: TimeoutId | undefined
+  function scheduleDurationLimitTimeout() {
+    if (durationLimitTimeoutId === undefined) {
+      durationLimitTimeoutId = setTimeout(() => {
+        flush('duration_limit')
+      }, FLUSH_DURATION_LIMIT)
+    }
+  }
+
+  function cancelDurationLimitTimeout() {
+    clearTimeout(durationLimitTimeoutId)
+    durationLimitTimeoutId = undefined
+  }
+
+  return {
+    flushObservable,
+    get messagesCount() {
+      return currentMessagesCount
+    },
+
+    /**
+     * Notifies that a message will be added to a pool of pending messages waiting to be flushed.
+     *
+     * 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(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 += estimatedMessageBytesCount
+      scheduleDurationLimitTimeout()
+    },
+
+    /**
+     * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.
+     *
+     * 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(messageBytesCountDiff = 0) {
+      currentBytesCount += messageBytesCountDiff
+
+      if (currentMessagesCount >= MESSAGES_LIMIT) {
+        flush('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()
+      }
+    },
+  }
+}