@openobserve/browser-core 0.3.2-beta.3 → 0.3.3

package/src/transport/flushController.spec.ts

@@ -1,267 +0,0 @@
-import type { Clock } from '../../test'
-import { mockClock } from '../../test'
-import type { PageMayExitEvent } from '../browser/pageMayExitObservable'
-import { Observable } from '../tools/observable'
-import type { FlushController, FlushEvent } from './flushController'
-import { createFlushController, FLUSH_DURATION_LIMIT, MESSAGES_LIMIT } from './flushController'
-import { RECOMMENDED_REQUEST_BYTES_LIMIT } from './httpRequest'
-
-const BYTES_LIMIT = RECOMMENDED_REQUEST_BYTES_LIMIT
-// Arbitrary message size that is below the BYTES_LIMIT
-const SMALL_MESSAGE_BYTE_COUNT = 2
-
-describe('flushController', () => {
-  let clock: Clock
-  let flushController: FlushController
-  let flushSpy: jasmine.Spy<(event: FlushEvent) => void>
-  let pageMayExitObservable: Observable<PageMayExitEvent>
-  let sessionExpireObservable: Observable<void>
-
-  beforeEach(() => {
-    clock = mockClock()
-    pageMayExitObservable = new Observable()
-    sessionExpireObservable = new Observable()
-    flushController = createFlushController({
-      pageMayExitObservable,
-      sessionExpireObservable,
-    })
-    flushSpy = jasmine.createSpy()
-    flushController.flushObservable.subscribe(flushSpy)
-  })
-
-  it('when flushing, the event contains a reason, the bytes count and the messages count', () => {
-    const messagesCount = 3
-    for (let i = 0; i < messagesCount; i += 1) {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-    }
-
-    pageMayExitObservable.notify({ reason: 'before_unload' })
-
-    expect(flushSpy).toHaveBeenCalledOnceWith({
-      reason: jasmine.any(String),
-      bytesCount: messagesCount * SMALL_MESSAGE_BYTE_COUNT,
-      messagesCount,
-    })
-  })
-
-  describe('page exit', () => {
-    it('notifies when the page is exiting', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      pageMayExitObservable.notify({ reason: 'before_unload' })
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('flush reason should be the page exit reason', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      pageMayExitObservable.notify({ reason: 'before_unload' })
-      expect(flushSpy.calls.first().args[0].reason).toBe('before_unload')
-    })
-
-    it('does not notify if no message was added', () => {
-      pageMayExitObservable.notify({ reason: 'before_unload' })
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('notifies when the page is exiting even if no message have been fully added yet', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      pageMayExitObservable.notify({ reason: 'before_unload' })
-      expect(flushSpy).toHaveBeenCalled()
-    })
-  })
-
-  describe('session expire', () => {
-    it('notifies when the session expires', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      sessionExpireObservable.notify()
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('flush reason should be "session_expire"', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      sessionExpireObservable.notify()
-      expect(flushSpy.calls.first().args[0].reason).toBe('session_expire')
-    })
-
-    it('does not notify if no message was added', () => {
-      sessionExpireObservable.notify()
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('notifies when the session expires even if no message have been fully added yet', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      sessionExpireObservable.notify()
-      expect(flushSpy).toHaveBeenCalled()
-    })
-  })
-
-  describe('bytes limit', () => {
-    it('notifies when the bytes limit is reached after adding a message', () => {
-      flushController.notifyBeforeAddMessage(BYTES_LIMIT)
-      flushController.notifyAfterAddMessage()
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('flush reason should be "bytes_limit"', () => {
-      flushController.notifyBeforeAddMessage(BYTES_LIMIT)
-      flushController.notifyAfterAddMessage()
-      expect(flushSpy.calls.first().args[0].reason).toBe('bytes_limit')
-    })
-
-    it('notifies when the bytes limit will be reached before adding a message', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      flushController.notifyBeforeAddMessage(BYTES_LIMIT)
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('does not take removed messages into account', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      flushController.notifyAfterRemoveMessage(SMALL_MESSAGE_BYTE_COUNT)
-
-      flushController.notifyBeforeAddMessage(BYTES_LIMIT - SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('does not notify when the bytes limit will be reached if no message was added yet', () => {
-      flushController.notifyBeforeAddMessage(BYTES_LIMIT)
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('resets the current bytes count once flushed', () => {
-      flushController.notifyBeforeAddMessage(BYTES_LIMIT)
-      flushController.notifyAfterAddMessage()
-
-      flushSpy.calls.reset()
-
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('messages limit', () => {
-    it('notifies when the messages limit is reached', () => {
-      for (let i = 0; i < MESSAGES_LIMIT; i += 1) {
-        flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-        flushController.notifyAfterAddMessage()
-      }
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('flush reason should be "messages_limit"', () => {
-      for (let i = 0; i < MESSAGES_LIMIT; i += 1) {
-        flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-        flushController.notifyAfterAddMessage()
-      }
-      expect(flushSpy.calls.first().args[0].reason).toBe('messages_limit')
-    })
-
-    it('does not flush when the message was not fully added yet', () => {
-      for (let i = 0; i < MESSAGES_LIMIT - 1; i += 1) {
-        flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-        flushController.notifyAfterAddMessage()
-      }
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('does not take removed messages into account', () => {
-      for (let i = 0; i < MESSAGES_LIMIT - 1; i += 1) {
-        flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-        flushController.notifyAfterAddMessage()
-      }
-
-      flushController.notifyAfterRemoveMessage(SMALL_MESSAGE_BYTE_COUNT)
-
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('resets the messages count when flushed', () => {
-      for (let i = 0; i < MESSAGES_LIMIT; i += 1) {
-        flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-        flushController.notifyAfterAddMessage()
-      }
-
-      flushSpy.calls.reset()
-
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('duration limit', () => {
-    it('notifies when the duration limit is reached after adding a message', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      clock.tick(FLUSH_DURATION_LIMIT)
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('flush reason should be "duration_limit"', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      clock.tick(FLUSH_DURATION_LIMIT)
-      expect(flushSpy.calls.first().args[0].reason).toBe('duration_limit')
-    })
-
-    it('does not postpone the duration limit when another message was added', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      clock.tick(FLUSH_DURATION_LIMIT / 2)
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      clock.tick(FLUSH_DURATION_LIMIT / 2)
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('does not notify if no message was added yet', () => {
-      clock.tick(FLUSH_DURATION_LIMIT)
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('does not notify if a message was added then removed', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      flushController.notifyAfterRemoveMessage(SMALL_MESSAGE_BYTE_COUNT)
-      clock.tick(FLUSH_DURATION_LIMIT)
-      expect(flushSpy).not.toHaveBeenCalled()
-    })
-
-    it('notifies if a message was added, and another was added then removed', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      flushController.notifyAfterRemoveMessage(SMALL_MESSAGE_BYTE_COUNT)
-
-      clock.tick(FLUSH_DURATION_LIMIT)
-      expect(flushSpy).toHaveBeenCalled()
-    })
-
-    it('does not notify prematurely if a message was added then removed then another was added', () => {
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      flushController.notifyAfterRemoveMessage(SMALL_MESSAGE_BYTE_COUNT)
-      clock.tick(FLUSH_DURATION_LIMIT / 2)
-      flushController.notifyBeforeAddMessage(SMALL_MESSAGE_BYTE_COUNT)
-      flushController.notifyAfterAddMessage()
-      clock.tick(FLUSH_DURATION_LIMIT / 2)
-      expect(flushSpy).not.toHaveBeenCalled()
-      clock.tick(FLUSH_DURATION_LIMIT / 2)
-      expect(flushSpy).toHaveBeenCalled()
-    })
-  })
-})

package/src/transport/httpRequest.spec.ts

@@ -1,400 +0,0 @@
-import {
-  collectAsyncCalls,
-  mockEndpointBuilder,
-  interceptRequests,
-  DEFAULT_FETCH_MOCK,
-  TOO_MANY_REQUESTS_FETCH_MOCK,
-  NETWORK_ERROR_FETCH_MOCK,
-  wait,
-} from '../../test'
-import type { Request } from '../../test'
-import type { EndpointBuilder } from '../domain/configuration'
-import { createEndpointBuilder } from '../domain/configuration'
-import { addExperimentalFeatures, resetExperimentalFeatures, ExperimentalFeature } from '../tools/experimentalFeatures'
-import { noop } from '../tools/utils/functionUtils'
-import {
-  createHttpRequest,
-  fetchKeepAliveStrategy,
-  fetchStrategy,
-  RECOMMENDED_REQUEST_BYTES_LIMIT,
-} from './httpRequest'
-import type { HttpRequest, HttpRequestEvent } from './httpRequest'
-
-describe('httpRequest', () => {
-  const ENDPOINT_URL = 'http://my.website'
-  let interceptor: ReturnType<typeof interceptRequests>
-  let requests: Request[]
-  let endpointBuilder: EndpointBuilder
-  let request: HttpRequest
-
-  beforeEach(() => {
-    interceptor = interceptRequests()
-    requests = interceptor.requests
-    endpointBuilder = mockEndpointBuilder(ENDPOINT_URL)
-    request = createHttpRequest([endpointBuilder], noop)
-  })
-
-  describe('send', () => {
-    it('should use fetch when fetch keepalive is not available', async () => {
-      interceptor.withRequest(false)
-
-      request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-      await interceptor.waitForAllFetchCalls()
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch')
-      expect(requests[0].url).toContain(ENDPOINT_URL)
-      expect(requests[0].body).toEqual('{"foo":"bar1"}\n{"foo":"bar2"}')
-    })
-
-    it('should use fetch keepalive when the bytes count is correct', async () => {
-      if (!interceptor.isFetchKeepAliveSupported()) {
-        pending('no fetch keepalive support')
-      }
-
-      request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-      await interceptor.waitForAllFetchCalls()
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch-keepalive')
-    })
-
-    it('should use fetch over fetch keepalive when the bytes count is too high', async () => {
-      request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: RECOMMENDED_REQUEST_BYTES_LIMIT })
-      await interceptor.waitForAllFetchCalls()
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch')
-    })
-
-    it('should fallback to fetch when fetch keepalive is not queued', async () => {
-      if (!interceptor.isFetchKeepAliveSupported()) {
-        pending('no fetch keepalive support')
-      }
-
-      const fetchSpy = interceptor.withFetch(NETWORK_ERROR_FETCH_MOCK, DEFAULT_FETCH_MOCK)
-
-      request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-      await interceptor.waitForAllFetchCalls()
-      await collectAsyncCalls(fetchSpy, 2)
-      expect(requests.length).toEqual(2)
-      expect(requests[0].type).toBe('fetch-keepalive')
-      expect(requests[1].type).toBe('fetch')
-    })
-
-    it('should use retry strategy', async () => {
-      if (!interceptor.isFetchKeepAliveSupported()) {
-        pending('no fetch keepalive support')
-      }
-
-      const fetchSpy = interceptor.withFetch(TOO_MANY_REQUESTS_FETCH_MOCK, DEFAULT_FETCH_MOCK)
-
-      request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-      await interceptor.waitForAllFetchCalls()
-      await collectAsyncCalls(fetchSpy, 2)
-    })
-
-    it('sends the payload to multiple endpoints', async () => {
-      const endpointBuilder2 = mockEndpointBuilder('http://my.website2')
-
-      request = createHttpRequest([endpointBuilder, endpointBuilder2], noop)
-
-      interceptor.withFetch(DEFAULT_FETCH_MOCK, DEFAULT_FETCH_MOCK)
-
-      const payloadData = '{"foo":"bar1"}\n{"foo":"bar2"}'
-      request.send({ data: payloadData, bytesCount: 10 })
-
-      await interceptor.waitForAllFetchCalls()
-      expect(requests.length).toEqual(2)
-      expect(requests[0].url).toContain('http://my.website')
-      expect(requests[0].body).toEqual(payloadData)
-      expect(requests[1].url).toContain('http://my.website2')
-      expect(requests[1].body).toEqual(payloadData)
-    })
-  })
-
-  describe('fetchKeepAliveStrategy onResponse', () => {
-    it('should be called with intake response when fetch is used', (done) => {
-      if (!interceptor.isFetchKeepAliveSupported()) {
-        pending('no fetch keepalive support')
-      }
-
-      interceptor.withFetch(TOO_MANY_REQUESTS_FETCH_MOCK)
-
-      fetchKeepAliveStrategy(
-        endpointBuilder,
-        RECOMMENDED_REQUEST_BYTES_LIMIT,
-        { data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 },
-        (response) => {
-          expect(response).toEqual({ status: 429, type: 'cors' })
-          done()
-        }
-      )
-    })
-
-    it('should be called with intake response when fallback to fetch due fetch keepalive not queued', (done) => {
-      if (!interceptor.isFetchKeepAliveSupported()) {
-        pending('no fetch keepalive support')
-      }
-
-      interceptor.withFetch(NETWORK_ERROR_FETCH_MOCK, TOO_MANY_REQUESTS_FETCH_MOCK)
-
-      fetchKeepAliveStrategy(
-        endpointBuilder,
-        RECOMMENDED_REQUEST_BYTES_LIMIT,
-        { data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 },
-        (response) => {
-          expect(response).toEqual({ status: 429, type: 'cors' })
-          done()
-        }
-      )
-    })
-
-    it('should be called with intake response when fallback to fetch due to size', (done) => {
-      interceptor.withFetch(TOO_MANY_REQUESTS_FETCH_MOCK)
-
-      fetchKeepAliveStrategy(
-        endpointBuilder,
-        RECOMMENDED_REQUEST_BYTES_LIMIT,
-        { data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: RECOMMENDED_REQUEST_BYTES_LIMIT },
-        (response) => {
-          expect(response).toEqual({ status: 429, type: 'cors' })
-          done()
-        }
-      )
-    })
-  })
-
-  describe('fetchStrategy onResponse', () => {
-    it('should be called with intake response', (done) => {
-      interceptor.withFetch(DEFAULT_FETCH_MOCK)
-
-      fetchStrategy(endpointBuilder, { data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 }, (response) => {
-        expect(response).toEqual({ status: 200, type: 'cors' })
-        done()
-      })
-    })
-
-    it('should be called with status 0 when fetch fails', (done) => {
-      interceptor.withFetch(NETWORK_ERROR_FETCH_MOCK)
-
-      fetchStrategy(endpointBuilder, { data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 }, (response) => {
-        expect(response).toEqual({ status: 0 })
-        done()
-      })
-    })
-  })
-
-  describe('sendOnExit', () => {
-    it('should use fetch when sendBeacon is not defined', async () => {
-      interceptor.withSendBeacon(false)
-
-      request.sendOnExit({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-      await interceptor.waitForAllFetchCalls()
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch')
-      expect(requests[0].url).toContain(ENDPOINT_URL)
-      expect(requests[0].body).toEqual('{"foo":"bar1"}\n{"foo":"bar2"}')
-    })
-
-    it('should use sendBeacon when the bytes count is correct', () => {
-      if (!interceptor.isSendBeaconSupported()) {
-        pending('no sendBeacon support')
-      }
-
-      request.sendOnExit({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('sendBeacon')
-    })
-
-    it('should use fetch over sendBeacon when the bytes count is too high', async () => {
-      request.sendOnExit({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: RECOMMENDED_REQUEST_BYTES_LIMIT })
-
-      await interceptor.waitForAllFetchCalls()
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch')
-    })
-
-    it('should fallback to fetch when sendBeacon is not queued', async () => {
-      if (!interceptor.isSendBeaconSupported()) {
-        pending('no sendBeacon support')
-      }
-      interceptor.withSendBeacon(() => false)
-
-      request.sendOnExit({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-      await interceptor.waitForAllFetchCalls()
-
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch')
-    })
-
-    it('should fallback to fetch when sendBeacon throws', async () => {
-      if (!interceptor.isSendBeaconSupported()) {
-        pending('no sendBeacon support')
-      }
-      let sendBeaconCalled = false
-      interceptor.withSendBeacon(() => {
-        sendBeaconCalled = true
-        throw new Error('mock sendBeacon error')
-      })
-
-      request.sendOnExit({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-      await interceptor.waitForAllFetchCalls()
-
-      expect(sendBeaconCalled).toBe(true)
-      expect(requests.length).toEqual(1)
-      expect(requests[0].type).toBe('fetch')
-    })
-  })
-
-  describe('HttpRequestEvent observable', () => {
-    const observedEvents: HttpRequestEvent[] = []
-
-    function latestEvents() {
-      const events = [...observedEvents]
-      observedEvents.length = 0
-      return events
-    }
-
-    beforeEach(() => {
-      request.observable.subscribe((event) => {
-        observedEvents.push(event)
-      })
-    })
-
-    afterEach(() => {
-      observedEvents.length = 0
-    })
-
-    it('should report success for successful requests', async () => {
-      interceptor.withFetch(DEFAULT_FETCH_MOCK)
-
-      const payload = { data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 }
-      request.send(payload)
-      await interceptor.waitForAllFetchCalls()
-      await wait(0)
-
-      expect(latestEvents()).toEqual([
-        { type: 'success', bandwidth: { ongoingByteCount: 0, ongoingRequestCount: 0 }, payload },
-      ])
-    })
-
-    it('should report failure for failing requests', async () => {
-      interceptor.withFetch(TOO_MANY_REQUESTS_FETCH_MOCK, DEFAULT_FETCH_MOCK)
-
-      const payload = { data: '{"foo":"barX"}\n{"foo":"barY"}', bytesCount: 10 }
-      request.send(payload)
-      await interceptor.waitForAllFetchCalls()
-      await wait(0)
-      await interceptor.waitForAllFetchCalls()
-      await wait(0)
-
-      expect(latestEvents()).toEqual([
-        { type: 'failure', bandwidth: { ongoingByteCount: 0, ongoingRequestCount: 0 }, payload },
-        { type: 'success', bandwidth: { ongoingByteCount: 0, ongoingRequestCount: 0 }, payload },
-      ])
-    })
-
-    it('should report multiple failures when requests are retried repeatedly', async () => {
-      interceptor.withFetch(TOO_MANY_REQUESTS_FETCH_MOCK, TOO_MANY_REQUESTS_FETCH_MOCK, DEFAULT_FETCH_MOCK)
-
-      const payload = { data: '{"foo":"barA"}\n{"foo":"barB"}', bytesCount: 10 }
-      request.send(payload)
-      await interceptor.waitForAllFetchCalls()
-      await wait(0)
-      await interceptor.waitForAllFetchCalls()
-      await wait(0)
-      await interceptor.waitForAllFetchCalls()
-      await wait(0)
-
-      expect(latestEvents()).toEqual([
-        { type: 'failure', bandwidth: { ongoingByteCount: 0, ongoingRequestCount: 0 }, payload },
-        { type: 'failure', bandwidth: { ongoingByteCount: 0, ongoingRequestCount: 0 }, payload },
-        { type: 'success', bandwidth: { ongoingByteCount: 0, ongoingRequestCount: 0 }, payload },
-      ])
-    })
-  })
-})
-
-describe('httpRequest intake parameters', () => {
-  const clientToken = 'some_client_token'
-  let interceptor: ReturnType<typeof interceptRequests>
-  let requests: Request[]
-  let endpointBuilder: EndpointBuilder
-  let request: HttpRequest
-
-  beforeEach(() => {
-    interceptor = interceptRequests()
-    requests = interceptor.requests
-    endpointBuilder = createEndpointBuilder({ clientToken }, 'logs')
-    request = createHttpRequest([endpointBuilder], noop)
-  })
-
-  it('should have a unique request id', async () => {
-    interceptor.withFetch(DEFAULT_FETCH_MOCK, DEFAULT_FETCH_MOCK)
-
-    request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-    request.send({ data: '{"foo":"bar1"}\n{"foo":"bar2"}', bytesCount: 10 })
-
-    await interceptor.waitForAllFetchCalls()
-
-    const search = /dd-request-id=([^&]*)/
-    const requestId1 = search.exec(requests[0].url)?.[1]
-    const requestId2 = search.exec(requests[1].url)?.[1]
-
-    expect(requestId1).not.toBe(requestId2)
-    expect(requests.length).toEqual(2)
-  })
-})
-
-describe('httpRequest with AVOID_FETCH_KEEPALIVE feature flag', () => {
-  const ENDPOINT_URL = 'http://my.website'
-  let interceptor: ReturnType<typeof interceptRequests>
-  let requests: Request[]
-  let endpointBuilder: EndpointBuilder
-  let request: HttpRequest
-
-  beforeEach(() => {
-    interceptor = interceptRequests()
-    requests = interceptor.requests
-    endpointBuilder = mockEndpointBuilder(ENDPOINT_URL)
-  })
-
-  afterEach(() => {
-    resetExperimentalFeatures()
-  })
-
-  it('should use regular fetch (without keepalive) when feature flag is enabled', async () => {
-    addExperimentalFeatures([ExperimentalFeature.AVOID_FETCH_KEEPALIVE])
-    request = createHttpRequest([endpointBuilder], noop)
-
-    request.send({ data: '{"foo":"bar"}', bytesCount: 10 })
-    await interceptor.waitForAllFetchCalls()
-
-    expect(requests.length).toEqual(1)
-    expect(requests[0].type).toBe('fetch')
-    expect(requests[0].url).toContain(ENDPOINT_URL)
-  })
-
-  it('should use fetch keepalive when feature flag is not enabled', async () => {
-    if (!interceptor.isFetchKeepAliveSupported()) {
-      pending('no fetch keepalive support')
-    }
-
-    request = createHttpRequest([endpointBuilder], noop)
-
-    request.send({ data: '{"foo":"bar"}', bytesCount: 10 })
-    await interceptor.waitForAllFetchCalls()
-
-    expect(requests.length).toEqual(1)
-    expect(requests[0].type).toBe('fetch-keepalive')
-  })
-})