@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

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

@@ -1,236 +0,0 @@
-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/endpointBuilder.spec.ts

@@ -1,173 +0,0 @@
-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/transportConfiguration.spec.ts

@@ -1,130 +0,0 @@
-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)
-      })
-  })
-})

package/src/domain/configuration/transportConfiguration.ts

@@ -1,78 +0,0 @@
-import type { Site } from '../intakeSites'
-import { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from '../intakeSites'
-import type { InitConfiguration } from './configuration'
-import type { EndpointBuilder } from './endpointBuilder'
-import { createEndpointBuilder } from './endpointBuilder'
-
-export interface TransportConfiguration {
-  logsEndpointBuilder: EndpointBuilder
-  rumEndpointBuilder: EndpointBuilder
-  sessionReplayEndpointBuilder: EndpointBuilder
-  profilingEndpointBuilder: EndpointBuilder
-  exposuresEndpointBuilder: EndpointBuilder
-  datacenter?: string | undefined
-  replica?: ReplicaConfiguration
-  site: Site
-  source: 'browser' | 'flutter' | 'unity'
-}
-
-export interface ReplicaConfiguration {
-  logsEndpointBuilder: EndpointBuilder
-  rumEndpointBuilder: EndpointBuilder
-}
-
-export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
-  const site = initConfiguration.site || INTAKE_SITE_US1
-  const source = validateSource(initConfiguration.source)
-
-  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, site, source })
-  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, site, source })
-
-  return {
-    replica: replicaConfiguration,
-    site,
-    source,
-    ...endpointBuilders,
-  }
-}
-
-function validateSource(source: string | undefined) {
-  if (source === 'flutter' || source === 'unity') {
-    return source
-  }
-  return 'browser'
-}
-
-function computeEndpointBuilders(initConfiguration: InitConfiguration) {
-  return {
-    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),
-    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),
-    profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),
-    exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),
-  }
-}
-
-function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
-  if (!initConfiguration.replica) {
-    return
-  }
-
-  const replicaConfiguration: InitConfiguration = {
-    ...initConfiguration,
-    site: INTAKE_SITE_US1,
-    clientToken: initConfiguration.replica.clientToken,
-  }
-
-  return {
-    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),
-    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [
-      `application.id=${initConfiguration.replica.applicationId}`,
-    ]),
-  }
-}
-
-export function isIntakeUrl(url: string): boolean {
-  // check if tags is present in the query string
-  return INTAKE_URL_PARAMETERS.every((param) => url.includes(param))
-}

package/src/domain/connectivity/connectivity.spec.ts

@@ -1,50 +0,0 @@
-import { setNavigatorOnLine, setNavigatorConnection } from '../../../test'
-import { getConnectivity } from './connectivity'
-
-describe('connectivity', () => {
-  describe('status', () => {
-    it('should return `connected` when navigator.onLine is true', () => {
-      setNavigatorOnLine(true)
-      expect(getConnectivity().status).toEqual('connected')
-    })
-
-    it('should return `not_connected` when navigator.onLine is false', () => {
-      setNavigatorOnLine(false)
-      expect(getConnectivity().status).toEqual('not_connected')
-    })
-  })
-
-  describe('interfaces', () => {
-    it('should not be defined if navigator.connection is not available', () => {
-      setNavigatorConnection(undefined)
-      expect(getConnectivity().interfaces).toBeUndefined()
-    })
-
-    it('should not be defined if navigator.connection.type is not available', () => {
-      setNavigatorConnection({})
-      expect(getConnectivity().interfaces).toBeUndefined()
-    })
-
-    it('should return navigator.connection.type value', () => {
-      setNavigatorConnection({ type: 'bluetooth' })
-      expect(getConnectivity().interfaces).toEqual(['bluetooth'])
-    })
-  })
-
-  describe('effective_type', () => {
-    it('should not be defined if navigator.connection is not available', () => {
-      setNavigatorConnection(undefined)
-      expect(getConnectivity().effective_type).toBeUndefined()
-    })
-
-    it('should not be defined if navigator.connection.effective_type is not available', () => {
-      setNavigatorConnection({})
-      expect(getConnectivity().effective_type).toBeUndefined()
-    })
-
-    it('should return navigator.connection.effective_type value', () => {
-      setNavigatorConnection({ effectiveType: '4g' })
-      expect(getConnectivity().effective_type).toBe('4g')
-    })
-  })
-})