@openobserve/browser-core 0.2.12-beta.9 → 0.3.1

package/src/domain/configuration/configuration.spec.ts

@@ -0,0 +1,236 @@
+import type { RumEvent } from '../../../../rum-core/src'
+import { EXHAUSTIVE_INIT_CONFIGURATION, SERIALIZED_EXHAUSTIVE_INIT_CONFIGURATION } from '../../../test'
+import type { ExtractTelemetryConfiguration, MapInitConfigurationKey } from '../../../test'
+import { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display'
+import {
+  ExperimentalFeature,
+  isExperimentalFeatureEnabled,
+  resetExperimentalFeatures,
+} from '../../tools/experimentalFeatures'
+import { SessionPersistence } from '../session/sessionConstants'
+import { TrackingConsent } from '../trackingConsent'
+import type { InitConfiguration } from './configuration'
+import { serializeConfiguration, validateAndBuildConfiguration } from './configuration'
+
+describe('validateAndBuildConfiguration', () => {
+  const clientToken = 'some_client_token'
+
+  let displaySpy: jasmine.Spy<typeof display.error>
+
+  beforeEach(() => {
+    displaySpy = spyOn(display, 'error')
+  })
+
+  afterEach(() => {
+    resetExperimentalFeatures()
+  })
+
+  describe('experimentalFeatures', () => {
+    const TEST_FEATURE_FLAG = 'foo' as ExperimentalFeature
+
+    beforeEach(() => {
+      ;(ExperimentalFeature as any).FOO = TEST_FEATURE_FLAG
+    })
+
+    afterEach(() => {
+      delete (ExperimentalFeature as any).FOO
+    })
+
+    it('ignores unknown experimental features', () => {
+      validateAndBuildConfiguration({
+        clientToken,
+        enableExperimentalFeatures: ['bar', undefined as any, null as any, 11 as any],
+      })
+      expect(isExperimentalFeatureEnabled('bar' as any)).toBeFalse()
+      expect(isExperimentalFeatureEnabled(undefined as any)).toBeFalse()
+      expect(isExperimentalFeatureEnabled(null as any)).toBeFalse()
+      expect(isExperimentalFeatureEnabled(11 as any)).toBeFalse()
+    })
+  })
+
+  describe('validate init configuration', () => {
+    it('requires the InitConfiguration to be defined', () => {
+      expect(validateAndBuildConfiguration(undefined as unknown as InitConfiguration)).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Client Token is not configured, we will not send any data.')
+    })
+
+    it('requires clientToken to be defined', () => {
+      expect(validateAndBuildConfiguration({} as unknown as InitConfiguration)).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Client Token is not configured, we will not send any data.')
+    })
+
+    it("shouldn't display any error if the configuration is correct", () => {
+      validateAndBuildConfiguration({ clientToken: 'yes' })
+      expect(displaySpy).not.toHaveBeenCalled()
+    })
+
+    it('requires sessionSampleRate to be a percentage', () => {
+      expect(
+        validateAndBuildConfiguration({ clientToken, sessionSampleRate: 'foo' } as unknown as InitConfiguration)
+      ).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Session Sample Rate should be a number between 0 and 100')
+
+      displaySpy.calls.reset()
+      expect(
+        validateAndBuildConfiguration({ clientToken, sessionSampleRate: 200 } as unknown as InitConfiguration)
+      ).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Session Sample Rate should be a number between 0 and 100')
+
+      displaySpy.calls.reset()
+      validateAndBuildConfiguration({ clientToken: 'yes', sessionSampleRate: 1 })
+      expect(displaySpy).not.toHaveBeenCalled()
+    })
+
+    it('requires telemetrySampleRate to be a percentage', () => {
+      expect(
+        validateAndBuildConfiguration({ clientToken, telemetrySampleRate: 'foo' } as unknown as InitConfiguration)
+      ).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Telemetry Sample Rate should be a number between 0 and 100')
+
+      displaySpy.calls.reset()
+      expect(
+        validateAndBuildConfiguration({ clientToken, telemetrySampleRate: 200 } as unknown as InitConfiguration)
+      ).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Telemetry Sample Rate should be a number between 0 and 100')
+
+      displaySpy.calls.reset()
+      validateAndBuildConfiguration({ clientToken: 'yes', telemetrySampleRate: 1 })
+      expect(displaySpy).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('sessionStoreStrategyType', () => {
+    it('is present in the returned configuration', () => {
+      const configuration = validateAndBuildConfiguration({ clientToken })
+      expect(configuration!.sessionStoreStrategyType).toEqual({
+        type: SessionPersistence.COOKIE,
+        cookieOptions: { secure: false, crossSite: false, partitioned: false },
+      })
+    })
+  })
+
+  describe('beforeSend', () => {
+    it('should be undefined when beforeSend is missing on user configuration', () => {
+      const configuration = validateAndBuildConfiguration({ clientToken })!
+      expect(configuration.beforeSend).toBeUndefined()
+    })
+
+    it('should return the same result as the original', () => {
+      const beforeSend = (event: RumEvent) => {
+        if (event.view.url === '/foo') {
+          return false
+        }
+      }
+      const configuration = validateAndBuildConfiguration({ clientToken, beforeSend })!
+      expect(configuration.beforeSend!({ view: { url: '/foo' } }, {})).toBeFalse()
+      expect(configuration.beforeSend!({ view: { url: '/bar' } }, {})).toBeUndefined()
+    })
+
+    it('should catch errors and log them', () => {
+      const myError = 'Ooops!'
+      const beforeSend = () => {
+        // eslint-disable-next-line @typescript-eslint/only-throw-error
+        throw myError
+      }
+      const configuration = validateAndBuildConfiguration({ clientToken, beforeSend })!
+      expect(configuration.beforeSend!(null, {})).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledWith('beforeSend threw an error:', myError)
+    })
+  })
+
+  describe('allowUntrustedEvents', () => {
+    it('defaults to false', () => {
+      expect(validateAndBuildConfiguration({ clientToken: 'yes' })!.allowUntrustedEvents).toBeFalse()
+    })
+
+    it('is set to provided value', () => {
+      expect(
+        validateAndBuildConfiguration({ clientToken: 'yes', allowUntrustedEvents: true })!.allowUntrustedEvents
+      ).toBeTrue()
+      expect(
+        validateAndBuildConfiguration({ clientToken: 'yes', allowUntrustedEvents: false })!.allowUntrustedEvents
+      ).toBeFalse()
+    })
+
+    it('the provided value is cast to boolean', () => {
+      expect(
+        validateAndBuildConfiguration({ clientToken: 'yes', allowUntrustedEvents: 'foo' as any })!.allowUntrustedEvents
+      ).toBeTrue()
+    })
+  })
+
+  describe('trackingConsent', () => {
+    it('defaults to "granted"', () => {
+      expect(validateAndBuildConfiguration({ clientToken: 'yes' })!.trackingConsent).toBe(TrackingConsent.GRANTED)
+    })
+
+    it('is set to provided value', () => {
+      expect(
+        validateAndBuildConfiguration({ clientToken: 'yes', trackingConsent: TrackingConsent.NOT_GRANTED })!
+          .trackingConsent
+      ).toBe(TrackingConsent.NOT_GRANTED)
+      expect(
+        validateAndBuildConfiguration({ clientToken: 'yes', trackingConsent: TrackingConsent.GRANTED })!.trackingConsent
+      ).toBe(TrackingConsent.GRANTED)
+    })
+
+    it('rejects invalid values', () => {
+      expect(validateAndBuildConfiguration({ clientToken: 'yes', trackingConsent: 'foo' as any })).toBeUndefined()
+      expect(displaySpy).toHaveBeenCalledOnceWith('Tracking Consent should be either "granted" or "not-granted"')
+    })
+  })
+
+  describe('site parameter validation', () => {
+    it('should validate the site parameter', () => {
+      validateAndBuildConfiguration({ clientToken, site: 'foo.com' as any })
+      expect(displaySpy).toHaveBeenCalledOnceWith(
+        `Site should be a valid Datadog site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`
+      )
+    })
+  })
+
+  describe('env parameter validation', () => {
+    it('should validate the env parameter', () => {
+      validateAndBuildConfiguration({ clientToken, env: false as any })
+      expect(displaySpy).toHaveBeenCalledOnceWith('Env must be defined as a string')
+    })
+  })
+
+  describe('service parameter validation', () => {
+    it('should validate the service parameter', () => {
+      validateAndBuildConfiguration({ clientToken, service: 1 as any })
+      expect(displaySpy).toHaveBeenCalledOnceWith('Service must be defined as a string')
+    })
+
+    it('should not reject null', () => {
+      const configuration = validateAndBuildConfiguration({ clientToken, service: null })
+      expect(displaySpy).not.toHaveBeenCalled()
+      expect(configuration!.service).toBeUndefined()
+    })
+  })
+
+  describe('version parameter validation', () => {
+    it('should validate the version parameter', () => {
+      validateAndBuildConfiguration({ clientToken, version: 0 as any })
+      expect(displaySpy).toHaveBeenCalledOnceWith('Version must be defined as a string')
+    })
+  })
+
+  describe('allowedTrackingOrigins parameter validation', () => {
+    it('should validate the allowedTrackingOrigins parameter', () => {
+      validateAndBuildConfiguration({ clientToken, allowedTrackingOrigins: 'foo' as any })
+      expect(displaySpy).toHaveBeenCalledOnceWith('Allowed Tracking Origins must be an array')
+    })
+  })
+
+  describe('serializeConfiguration', () => {
+    it('should serialize the configuration', () => {
+      // By specifying the type here, we can ensure that serializeConfiguration is returning an
+      // object containing all expected properties.
+      const serializedConfiguration: ExtractTelemetryConfiguration<MapInitConfigurationKey<keyof InitConfiguration>> =
+        serializeConfiguration(EXHAUSTIVE_INIT_CONFIGURATION)
+
+      expect(serializedConfiguration).toEqual(SERIALIZED_EXHAUSTIVE_INIT_CONFIGURATION)
+    })
+  })
+})

package/src/domain/configuration/configuration.ts

@@ -348,11 +348,12 @@ function isString(tag: unknown, tagName: string): tag is string | undefined | nu
 }
 
 function isDatadogSite(site: unknown) {
-  if (site && typeof site === 'string' && !/(datadog|ddog|datad0g|dd0g)/.test(site)) {
-    display.error(`Site should be a valid Datadog site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`)
-    return false
-  }
-  return true
+  return true;
+  // if (site && typeof site === 'string' && !/(datadog|ddog|datad0g|dd0g)/.test(site)) {
+  //   display.error(`Site should be a valid Datadog site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`)
+  //   return false
+  // }
+  // return true
 }
 
 export function isSampleRate(sampleRate: unknown, name: string) {

package/src/domain/configuration/endpointBuilder.spec.ts

@@ -0,0 +1,173 @@
+import type { Payload } from '../../transport'
+import type { InitConfiguration } from './configuration'
+import { createEndpointBuilder } from './endpointBuilder'
+
+const DEFAULT_PAYLOAD = {} as Payload
+
+describe('endpointBuilder', () => {
+  const clientToken = 'some_client_token'
+  let initConfiguration: InitConfiguration
+
+  beforeEach(() => {
+    initConfiguration = { clientToken, apiVersion: 'v1', organizationIdentifier: 'xyz', insecureHTTP: false }
+  })
+
+  describe('query parameters', () => {
+    it('should add intake query parameters', () => {
+      expect(createEndpointBuilder(initConfiguration, 'rum').build('fetch', DEFAULT_PAYLOAD)).toMatch(
+        `&o2-api-key=${clientToken}&o2-evp-origin-version=(.*)&o2-evp-origin=browser&o2-request-id=(.*)`
+      )
+    })
+
+    it('should add batch_time for rum endpoint', () => {
+      expect(createEndpointBuilder(initConfiguration, 'rum').build('fetch', DEFAULT_PAYLOAD)).toContain('&batch_time=')
+    })
+
+    it('should not add batch_time for logs and replay endpoints', () => {
+      expect(createEndpointBuilder(initConfiguration, 'logs').build('fetch', DEFAULT_PAYLOAD)).not.toContain(
+        '&batch_time='
+      )
+      expect(createEndpointBuilder(initConfiguration, 'replay').build('fetch', DEFAULT_PAYLOAD)).not.toContain(
+        '&batch_time='
+      )
+    })
+
+    it('should add the provided encoding', () => {
+      expect(
+        createEndpointBuilder(initConfiguration, 'rum').build('fetch', { ...DEFAULT_PAYLOAD, encoding: 'deflate' })
+      ).toContain('&dd-evp-encoding=deflate')
+    })
+
+    it('should not start with o2source for internal analytics mode', () => {
+      const url = createEndpointBuilder({ ...initConfiguration, internalAnalyticsSubdomain: 'foo' }, 'rum').build(
+        'fetch',
+        DEFAULT_PAYLOAD
+      )
+      expect(url).not.toContain('/rum?o2source')
+      expect(url).toContain('o2source=browser')
+    })
+
+    it('accepts extra parameters', () => {
+      const extraParameters = ['application.id=1234', 'application.version=1.0.0']
+      const url = createEndpointBuilder(initConfiguration, 'rum', extraParameters).build('fetch', DEFAULT_PAYLOAD)
+      expect(url).toContain('application.id=1234')
+      expect(url).toContain('application.version=1.0.0')
+    })
+  })
+
+  describe('proxy configuration', () => {
+    it('should replace the intake endpoint by the proxy and set the intake path and parameters in the attribute ooforward', () => {
+      expect(
+        createEndpointBuilder({ ...initConfiguration, proxy: 'https://proxy.io/path' }, 'rum').build(
+          'fetch',
+          DEFAULT_PAYLOAD
+        )
+      ).toMatch(
+        `https://proxy.io/path\\?ooforward=${encodeURIComponent(
+          `/rum/v2/rum?o2source=(.*)&o2-api-key=${clientToken}` +
+            '&o2-evp-origin-version=(.*)&o2-evp-origin=browser&o2-request-id=(.*)&batch_time=(.*)'
+        )}`
+      )
+    })
+
+    it('normalizes the proxy url', () => {
+      const endpoint = createEndpointBuilder({ ...initConfiguration, proxy: '/path' }, 'rum').build(
+        'fetch',
+        DEFAULT_PAYLOAD
+      )
+      expect(endpoint.startsWith(`${location.origin}/path?ooforward`)).toBeTrue()
+    })
+
+    it('should allow to fully control the proxy url', () => {
+      const proxyFn = (options: { path: string; parameters: string }) =>
+        `https://proxy.io/prefix${options.path}/suffix?${options.parameters}`
+      expect(
+        createEndpointBuilder({ ...initConfiguration, proxy: proxyFn }, 'rum').build('fetch', DEFAULT_PAYLOAD)
+      ).toMatch(
+        `https://proxy.io/prefix/api/v2/rum/suffix\\?oosource=(.*)&o2-api-key=${clientToken}&o2-evp-origin-version=(.*)&o2-evp-origin=browser&o2-request-id=(.*)&batch_time=(.*)`
+      )
+    })
+  })
+
+  describe('_o2 attributes', () => {
+    it('should contain api', () => {
+      expect(createEndpointBuilder(initConfiguration, 'rum').build('fetch', DEFAULT_PAYLOAD)).toContain('_o2.api=fetch')
+    })
+
+    it('should contain retry infos', () => {
+      expect(
+        createEndpointBuilder(initConfiguration, 'rum').build('fetch', {
+          ...DEFAULT_PAYLOAD,
+          retry: {
+            count: 5,
+            lastFailureStatus: 408,
+          },
+        })
+      ).toContain('_oo.retry_count=5&_oo.retry_after=408')
+    })
+
+    it('should not contain any _oo attributes for non rum endpoints', () => {
+      expect(
+        createEndpointBuilder(initConfiguration, 'logs').build('fetch', {
+          ...DEFAULT_PAYLOAD,
+          retry: {
+            count: 5,
+            lastFailureStatus: 408,
+          },
+        })
+      ).not.toContain('_o2.api=fetch&_o2.retry_count=5&_o2.retry_after=408')
+    })
+  })
+
+  describe('PCI compliance intake with option', () => {
+    it('should return PCI compliance intake endpoint if site is us1', () => {
+      const config: InitConfiguration & { usePciIntake?: boolean } = {
+        clientToken,
+        usePciIntake: true,
+        site: 'datadoghq.com',
+      }
+      expect(createEndpointBuilder(config, 'logs').build('fetch', DEFAULT_PAYLOAD)).toContain(
+        'https://pci.browser-intake-datadoghq.com'
+      )
+    })
+    it('should not return PCI compliance intake endpoint if site is not us1', () => {
+      const config: InitConfiguration & { usePciIntake?: boolean } = {
+        clientToken,
+        usePciIntake: true,
+        site: 'ap1.datadoghq.com',
+      }
+      expect(createEndpointBuilder(config, 'logs').build('fetch', DEFAULT_PAYLOAD)).not.toContain(
+        'https://pci.browser-intake-datadoghq.com'
+      )
+    })
+    it('should not return PCI compliance intake endpoint if and site is us1 and track is not logs', () => {
+      const config: InitConfiguration & { usePciIntake?: boolean } = {
+        clientToken,
+        usePciIntake: true,
+        site: 'datadoghq.com',
+      }
+      expect(createEndpointBuilder(config, 'rum').build('fetch', DEFAULT_PAYLOAD)).not.toContain(
+        'https://pci.browser-intake-datadoghq.com'
+      )
+    })
+  })
+
+  describe('source configuration', () => {
+    it('should use the default source when no configuration is provided', () => {
+      const endpoint = createEndpointBuilder(initConfiguration, 'rum').build('fetch', DEFAULT_PAYLOAD)
+      expect(endpoint).toContain('ddsource=browser')
+    })
+
+    it('should use flutter source when provided', () => {
+      const config = { ...initConfiguration, source: 'flutter' as const }
+      const endpoint = createEndpointBuilder(config, 'rum').build('fetch', DEFAULT_PAYLOAD)
+      expect(endpoint).toContain('ddsource=flutter')
+    })
+
+    it('should use unity source when provided', () => {
+      const config = { ...initConfiguration, source: 'unity' as const }
+      const endpoint = createEndpointBuilder(config, 'rum').build('fetch', DEFAULT_PAYLOAD)
+      expect(endpoint).toContain('ddsource=unity')
+    })
+  })
+})

package/src/domain/configuration/endpointBuilder.ts

@@ -25,7 +25,7 @@ export function createEndpointBuilder(
   extraParameters?: string[]
 ) {
   const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)
-
+  
   return {
     build(api: ApiType, payload: Payload) {
       const parameters = buildEndpointParameters(initConfiguration, trackType, api, payload, extraParameters)
@@ -44,19 +44,20 @@ function createEndpointUrlWithParametersBuilder(
   initConfiguration: InitConfiguration,
   trackType: TrackType
 ): (parameters: string) => string {
-  const { proxy, proxyUrl, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
-
-  const path = `/rum/${apiVersion}/${organizationIdentifier}/${INTAKE_TRACKS[trackType]}`
+  // const path = `/api/v2/${trackType}`
+  const { proxy, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
 
-  if (proxy) {
+  const path = `/rum/${apiVersion}/${organizationIdentifier}/${trackType}`
+  if (typeof proxy === 'string') {
     const normalizedProxyUrl = normalizeUrl(proxy)
-    return (parameters) => `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`${path}?${parameters}`)}`
+    return (parameters) => `${normalizedProxyUrl}?o2forward=${encodeURIComponent(`${path}?${parameters}`)}`
   }
   if (typeof proxy === 'function') {
     return (parameters) => proxy({ path, parameters })
   }
   const host = buildEndpointHost(trackType, initConfiguration)
-  return (parameters) => `https://${host}${path}?${parameters}`
+  const protocol = insecureHTTP ? 'http' : 'https'
+  return (parameters) => `${protocol}://${host}${path}?${parameters}`
 }
 
 export function buildEndpointHost(
@@ -66,6 +67,11 @@ export function buildEndpointHost(
   const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration
 
   return site
+
+  if (trackType === 'logs' && initConfiguration.usePciIntake && site === INTAKE_SITE_US1) {
+    return PCI_INTAKE_HOST_US1
+  }
+
   if (internalAnalyticsSubdomain && site === INTAKE_SITE_US1) {
     return `${internalAnalyticsSubdomain}.${INTAKE_SITE_US1}`
   }
@@ -91,7 +97,7 @@ function buildEndpointParameters(
   extraParameters: string[] = []
 ) {
   const parameters = [
-    'o2source=browser',
+    `o2source=${source}`,
     `o2-api-key=${clientToken}`,
     `o2-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,
     'o2-evp-origin=browser',
@@ -99,14 +105,14 @@ function buildEndpointParameters(
   ].concat(extraParameters)
 
   if (encoding) {
-    parameters.push(`dd-evp-encoding=${encoding}`)
+    parameters.push(`o2-evp-encoding=${encoding}`)
   }
 
   if (trackType === 'rum') {
-    parameters.push(`batch_time=${timeStampNow()}`, `_dd.api=${api}`)
+    parameters.push(`batch_time=${timeStampNow()}`, `_o2.api=${api}`)
 
     if (retry) {
-      parameters.push(`_dd.retry_count=${retry.count}`, `_dd.retry_after=${retry.lastFailureStatus}`)
+      parameters.push(`_o2.retry_count=${retry.count}`, `_o2.retry_after=${retry.lastFailureStatus}`)
     }
   }
 
@@ -115,4 +121,4 @@ function buildEndpointParameters(
   }
 
   return parameters.join('&')
-}
+}

package/src/domain/configuration/transportConfiguration.spec.ts

@@ -0,0 +1,130 @@
+import { INTAKE_SITE_FED_STAGING } from '../intakeSites'
+import type { Payload } from '../../transport'
+import { computeTransportConfiguration, isIntakeUrl } from './transportConfiguration'
+
+const DEFAULT_PAYLOAD = {} as Payload
+
+describe('transportConfiguration', () => {
+  const clientToken = 'some_client_token'
+  const internalAnalyticsSubdomain = 'ia-rum-intake'
+  const intakeParameters = 'ddsource=browser&dd-api-key=xxxx&dd-request-id=1234567890'
+
+  describe('site', () => {
+    it('should use US site by default', () => {
+      const configuration = computeTransportConfiguration({ clientToken })
+      expect(configuration.rumEndpointBuilder.build('fetch', DEFAULT_PAYLOAD)).toContain('openobserve.ai')
+      expect(configuration.site).toBe('openobserve.ai')
+    })
+
+    it('should use logs intake domain for fed staging', () => {
+      const configuration = computeTransportConfiguration({ clientToken, site: INTAKE_SITE_FED_STAGING })
+      expect(configuration.rumEndpointBuilder.build('fetch', DEFAULT_PAYLOAD)).toContain(
+        'http-intake.logs.dd0g-gov.com'
+      )
+      expect(configuration.site).toBe(INTAKE_SITE_FED_STAGING)
+    })
+
+    it('should use site value when set', () => {
+      const configuration = computeTransportConfiguration({ clientToken, site: 'openobserve.ai' })
+      expect(configuration.rumEndpointBuilder.build('fetch', DEFAULT_PAYLOAD)).toContain('openobserve.ai')
+      expect(configuration.site).toBe('openobserve.ai')
+    })
+  })
+
+  describe('internalAnalyticsSubdomain', () => {
+    it('should use internal analytics subdomain value when set for openobserve.ai site', () => {
+      const configuration = computeTransportConfiguration({
+        clientToken,
+        internalAnalyticsSubdomain,
+      })
+      expect(configuration.rumEndpointBuilder.build('fetch', DEFAULT_PAYLOAD)).toContain(internalAnalyticsSubdomain)
+    })
+
+    it('should not use internal analytics subdomain value when set for other sites', () => {
+      const configuration = computeTransportConfiguration({
+        clientToken,
+        site: 'us3.datadoghq.com',
+        internalAnalyticsSubdomain,
+      })
+      expect(configuration.rumEndpointBuilder.build('fetch', DEFAULT_PAYLOAD)).not.toContain(internalAnalyticsSubdomain)
+    })
+  })
+
+  it('adds the replica application id to the rum replica endpoint', () => {
+    const replicaApplicationId = 'replica-application-id'
+    const configuration = computeTransportConfiguration({
+      clientToken,
+      replica: {
+        clientToken: 'replica-client-token',
+        applicationId: replicaApplicationId,
+      },
+    })
+    expect(configuration.replica!.rumEndpointBuilder.build('fetch', DEFAULT_PAYLOAD)).toContain(
+      `application.id=${replicaApplicationId}`
+    )
+  })
+
+  describe('isIntakeUrl', () => {
+    const v1IntakePath = `/v1/input/${clientToken}`
+    ;[
+      { expectSubdomain: true, site: 'api.openobserve.ai', intakeDomain: 'api.openobserve.ai' },
+    ].forEach(({ site, intakeDomain, expectSubdomain }) => {
+      it(`should detect intake request for ${site} site`, () => {
+        const configuration = computeTransportConfiguration({ clientToken, site })
+
+        expect(configuration.isIntakeUrl(`https://${intakeDomain}/rum/v2/rum?xxx`)).toBe(expectSubdomain)
+        expect(configuration.isIntakeUrl(`https://${intakeDomain}/rum/v2/logs?xxx`)).toBe(expectSubdomain)
+        expect(configuration.isIntakeUrl(`https://${intakeDomain}/rum/v2/replay?xxx`)).toBe(
+          expectSubdomain
+        )
+
+        expect(configuration.isIntakeUrl(`https://${intakeDomain}/rum/v2/rum?xxx`)).toBe(!expectSubdomain)
+        expect(configuration.isIntakeUrl(`https://${intakeDomain}/rum/v2/logs?xxx`)).toBe(!expectSubdomain)
+        expect(configuration.isIntakeUrl(`https://${intakeDomain}/rum/v2/replay?xxx`)).toBe(!expectSubdomain)
+      })
+    })
+
+    it('should detect internal analytics intake request for openobserve.ai site', () => {
+      const configuration = computeTransportConfiguration({
+        clientToken,
+        internalAnalyticsSubdomain,
+      })
+      expect(configuration.isIntakeUrl(`https://api.openobserve.ai/rum/v2/rum?xxx`)).toBe(true)
+    })
+
+    it('should not detect non intake request', () => {
+      expect(isIntakeUrl('https://www.foo.com')).toBe(false)
+    })
+
+    describe('proxy configuration', () => {
+      it('should detect proxy intake request', () => {
+        expect(
+          isIntakeUrl(`https://www.proxy.com/?ooforward=${encodeURIComponent(`/api/v2/rum?${intakeParameters}`)}`)
+        ).toBe(true)
+        expect(
+          isIntakeUrl(
+            `https://www.proxy.com/custom/path?ooforward=${encodeURIComponent(`/api/v2/rum?${intakeParameters}`)}`
+          )
+        ).toBe(true)
+      })
+
+      it('should not detect request done on the same host as the proxy', () => {
+        expect(isIntakeUrl('https://www.proxy.com/foo')).toBe(false)
+      })
+    })
+    ;[
+      { site: 'openobserve.ai' },
+    ].forEach(({ site }) => {
+      it(`should detect replica intake request for site ${site}`, () => {
+        expect(isIntakeUrl(`https://${internalAnalyticsSubdomain}.openobserve.ai/api/v2/rum?${intakeParameters}`)).toBe(
+          true
+        )
+        expect(isIntakeUrl(`https://${internalAnalyticsSubdomain}.openobserve.ai/api/v2/logs?${intakeParameters}`)).toBe(
+          true
+        )
+        expect(
+          isIntakeUrl(`https://${internalAnalyticsSubdomain}.openobserve.ai/api/v2/replay?${intakeParameters}`)
+        ).toBe(true)
+      })
+  })
+})