🐛 [RUM-5645] Add a ff to avoid using "fetch keepalive"

packages/core/src/tools/experimentalFeatures.ts

@@ -18,6 +18,7 @@ export enum ExperimentalFeature {
   TRACK_INTAKE_REQUESTS = 'track_intake_requests',
   USER_ACCOUNT_TRACE_HEADER = 'user_account_trace_header',
   WRITABLE_RESOURCE_GRAPHQL = 'writable_resource_graphql',
+  AVOID_FETCH_KEEPALIVE = 'avoid_fetch_keepalive',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()

packages/core/src/transport/httpRequest.spec.ts

@@ -9,6 +9,7 @@ import {
 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 } from './httpRequest'
 import type { HttpRequest } from './httpRequest'
@@ -263,3 +264,48 @@ describe('httpRequest intake parameters', () => {
     expect(requests.length).toEqual(2)
   })
 })
+
+describe('httpRequest with AVOID_FETCH_KEEPALIVE feature flag', () => {
+  const BATCH_BYTES_LIMIT = 100
+  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, BATCH_BYTES_LIMIT, 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, BATCH_BYTES_LIMIT, noop)
+
+    request.send({ data: '{"foo":"bar"}', bytesCount: 10 })
+    await interceptor.waitForAllFetchCalls()
+
+    expect(requests.length).toEqual(1)
+    expect(requests[0].type).toBe('fetch-keepalive')
+  })
+})

packages/core/src/transport/httpRequest.ts

@@ -2,6 +2,7 @@ import type { EndpointBuilder } from '../domain/configuration'
 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 { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'
 
 /**
@@ -38,8 +39,13 @@ export function createHttpRequest(
   reportError: (error: RawError) => void
 ) {
   const retryState = newRetryState()
-  const sendStrategyForRetry = (payload: Payload, onResponse: (r: HttpResponse) => void) =>
-    fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse)
+  const sendStrategyForRetry = (payload: Payload, onResponse: (r: HttpResponse) => void) => {
+    if (isExperimentalFeatureEnabled(ExperimentalFeature.AVOID_FETCH_KEEPALIVE)) {
+      fetchStrategy(endpointBuilder, payload, onResponse)
+    } else {
+      fetchKeepAliveStrategy(endpointBuilder, bytesLimit, payload, onResponse)
+    }
+  }
 
   return {
     send: (payload: Payload) => {