@kubesense/kubesense-browser-core 1.0.0

package/src/domain/configuration/configuration.ts

@@ -0,0 +1,409 @@
+import { catchUserErrors } from '../../tools/catchUserErrors'
+import { DOCS_ORIGIN, MORE_DETAILS, display } from '../../tools/display'
+import type { RawTelemetryConfiguration } from '../telemetry'
+import { isPercentage } from '../../tools/utils/numberUtils'
+import { objectHasValue } from '../../tools/utils/objectUtils'
+import { selectSessionStoreStrategyType } from '../session/sessionStore'
+import type { SessionStoreStrategyType } from '../session/storeStrategies/sessionStoreStrategy'
+import { TrackingConsent } from '../trackingConsent'
+import type { SessionPersistence } from '../session/sessionConstants'
+import type { MatchOption } from '../../tools/matchOption'
+import { isAllowedTrackingOrigins } from '../allowedTrackingOrigins'
+import { isWorkerEnvironment } from '../../tools/globalObject'
+import type { TransportConfiguration } from './transportConfiguration'
+import { computeTransportConfiguration } from './transportConfiguration'
+import type { Site } from '../intakeSites'
+
+/**
+ * Default privacy level for the browser SDK.
+ *
+ * [Replay Privacy Options](https://docs.kubesense.ai/real_user_monitoring/session_replay/browser/privacy_options) for further information.
+ */
+export const DefaultPrivacyLevel = {
+  ALLOW: 'allow',
+  MASK: 'mask',
+  MASK_USER_INPUT: 'mask-user-input',
+  MASK_UNLESS_ALLOWLISTED: 'mask-unless-allowlisted',
+} as const
+export type DefaultPrivacyLevel = (typeof DefaultPrivacyLevel)[keyof typeof DefaultPrivacyLevel]
+
+/**
+ * Trace context injection option.
+ *
+ * See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
+ */
+export const TraceContextInjection = {
+  ALL: 'all',
+  SAMPLED: 'sampled',
+} as const
+
+/**
+ * Trace context injection option.
+ *
+ * See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
+ *
+ */
+export type TraceContextInjection = (typeof TraceContextInjection)[keyof typeof TraceContextInjection]
+
+export interface InitConfiguration {
+  /**
+   * The client token for Kubsesense. Required for authenticating your application with Kubsesense.
+   * 
+   * @category Authentication
+   */
+  clientToken: string
+  /**
+   * A callback function that can be used to modify events before they are sent to Kubsesense.
+   * 
+   *  @category Data Collection
+   */
+  beforeSend?: GenericBeforeSendCallback | undefined
+  /**
+   * The percentage of sessions tracked. A value between 0 and 100.
+   * 
+   * @category Data Collection
+   * @defaultValue 100
+   */
+  sessionSampleRate?: number | undefined
+  /**
+   * The percentage of telemetry events sent. A value between 0 and 100.
+   * 
+   * @category Data Collection
+   * @defaultValue 20
+   */
+  telemetrySampleRate?: number | undefined
+  /**
+   * Initialization fails silently if the RUM Browser SDK is already initialized on the page.
+   * @defaultValue false
+   */
+  silentMultipleInit?: boolean | undefined
+
+  /**
+   * Which storage strategy to use for persisting sessions. Can be either 'cookie' or 'local-storage'.
+   *
+   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   * 
+   * @category Session Persistence
+   * @defaultValue "cookie"
+   */
+  sessionPersistence?: SessionPersistence | undefined
+
+  /**
+   * Allows the use of localStorage when cookies cannot be set. This enables the RUM Browser SDK to run in environments that do not provide cookie support.
+   *
+   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   * @category Session Persistence
+   * @deprecated use `sessionPersistence: local-storage` where you want to use localStorage instead
+   */
+  allowFallbackToLocalStorage?: boolean | undefined
+
+  /**
+   * Allow listening to DOM events dispatched programmatically ([untrusted events](https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted)). Enabling this option can be useful if you heavily rely on programmatic events, such as in an automated UI test environment.
+   * @defaultValue false
+   */
+  allowUntrustedEvents?: boolean | undefined
+  /**
+   * Store global context and user context in localStorage to preserve them along the user navigation.
+   * @defaultValue false
+   */
+  storeContextsAcrossPages?: boolean | undefined
+  /**
+   * Set the initial user tracking consent state.
+   * 
+   * @category Privacy
+   * @defaultValue granted
+   */
+  trackingConsent?: TrackingConsent | undefined
+
+  /**
+   * List of origins where the SDK is allowed to run when used in a browser extension context.
+   * Matches urls against the extensions origin.
+   * If not provided and the SDK is running in a browser extension, the SDK will not run.
+   */
+  allowedTrackingOrigins?: MatchOption[] | undefined
+
+  // transport options
+  /**
+   * Optional proxy URL, for example: https://www.proxy.com/path.
+   * 
+   * @category Transport
+   */
+  proxy?: string | ProxyFn | undefined
+  /**
+   * 
+   * @category Transport
+   * @defaultValue rum.kubesense.ai
+   */
+  kubesenseRumEndpoint?: Site | undefined | null
+
+  // tag and context options
+  /**
+   * The service name for your application. 
+   * 
+   *  @category Data Collection
+   */
+  service?: string | undefined | null
+  /**
+   * The application’s environment, for example: prod, pre-prod, and staging.
+   * 
+   *  @category Data Collection
+   */
+  env?: string | undefined | null
+  /**
+   * The application’s version, for example: 1.2.3, 6c44da20, and 2020.02.13. 
+   * 
+   *  @category Data Collection
+   */
+  version?: string | undefined | null
+
+  // cookie options
+  /**
+   * Use a partitioned secure cross-site session cookie. This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`.
+   *
+   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   * @category Session Persistence
+   * @defaultValue false
+   */
+  usePartitionedCrossSiteSessionCookie?: boolean | undefined
+  /**
+   * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.
+   *
+   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   * @category Session Persistence
+   * @defaultValue false
+   */
+  useSecureSessionCookie?: boolean | undefined
+  /**
+   * Preserve the session across subdomains for the same site.
+   *
+   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   * @category Session Persistence
+   * @defaultValue false
+   */
+  trackSessionAcrossSubdomains?: boolean | undefined
+  /**
+   * Track anonymous user for the same site and extend cookie expiration date
+   * @category Data Collection
+   * @defaultValue true
+   */
+  trackAnonymousUser?: boolean | undefined
+  /**
+   * Encode cookie options in the cookie value. This can be used as a mitigation for microssession issues.
+   * ⚠️ This is a beta feature and may be changed or removed in the future.
+   *
+   * @category Beta
+   * @defaultValue false
+   */
+  betaEncodeCookieOptions?: boolean | undefined
+  // internal options
+  /**
+   * [Internal option] Enable experimental features
+   * @internal
+   */
+  enableExperimentalFeatures?: string[] | undefined
+  /**
+   * [Internal option] Configure the dual shipping to another datacenter
+   * @internal
+   */
+  replica?: ReplicaUserConfiguration | undefined
+  /**
+   * [Internal option] Set the datacenter from where the data is dual shipped
+   * @internal
+   */
+  datacenter?: string
+  /**
+   * [Internal option] Kubsesense internal analytics subdomain
+   * @internal
+   */
+  // TODO next major: remove this option and replace usages by proxyFn
+  internalAnalyticsSubdomain?: string
+  /**
+   * [Internal option] The percentage of telemetry configuration sent. A value between 0 and 100.
+   * @internal
+   * @defaultValue 5
+   */
+  telemetryConfigurationSampleRate?: number
+  /**
+   * [Internal option] The percentage of telemetry usage sent. A value between 0 and 100.
+   * @internal
+   * @defaultValue 5
+   */
+  telemetryUsageSampleRate?: number
+
+  /**
+   * [Internal option] Additional configuration for the SDK.
+   *
+   * @internal
+   */
+  source?: 'browser' | 'flutter' | 'unity' | undefined
+
+  /**
+  * [Internal option] Additional configuration for the SDK.
+  *
+  * @internal
+  */
+  sdkVersion?: string | undefined
+
+  /**
+  * [Internal option] Additional configuration for the SDK.
+  *
+  * @internal
+  */
+  variant?: string | undefined
+}
+
+// This type is only used to build the core configuration. Logs and RUM SDKs are using a proper type
+// for this option.
+type GenericBeforeSendCallback = (event: any, context?: any) => unknown
+
+/**
+ * path: /api/vX/product
+ * parameters: xxx=yyy&zzz=aaa
+ */
+export type ProxyFn = (options: { path: string; parameters: string }) => string
+
+export interface ReplicaUserConfiguration {
+  applicationId?: string
+  clientToken: string
+}
+
+export interface Configuration extends TransportConfiguration {
+  // Built from init configuration
+  beforeSend: GenericBeforeSendCallback | undefined
+  sessionStoreStrategyType: SessionStoreStrategyType | undefined
+  sessionSampleRate: number
+  telemetrySampleRate: number
+  telemetryConfigurationSampleRate: number
+  telemetryUsageSampleRate: number
+  service: string | undefined
+  version?: string | undefined
+  env?: string | undefined
+  silentMultipleInit: boolean
+  allowUntrustedEvents: boolean
+  trackingConsent: TrackingConsent
+  storeContextsAcrossPages: boolean
+  trackAnonymousUser?: boolean
+  betaEncodeCookieOptions: boolean
+
+  // internal
+  sdkVersion: string | undefined
+  source: 'browser' | 'flutter' | 'unity'
+  variant: string | undefined
+}
+
+function isString(tag: unknown, tagName: string): tag is string | undefined | null {
+  if (tag !== undefined && tag !== null && typeof tag !== 'string') {
+    display.error(`${tagName} must be defined as a string`)
+    return false
+  }
+  return true
+}
+
+function isKubsesenseSite(site: unknown) {
+  if (site && typeof site === 'string' && !/(kubesense|tyke)/.test(site)) {
+    display.error(`Site should be a valid Kubsesense site. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/site/.`)
+    return false
+  }
+  return true
+}
+
+export function isSampleRate(sampleRate: unknown, name: string) {
+  if (sampleRate !== undefined && !isPercentage(sampleRate)) {
+    display.error(`${name} Sample Rate should be a number between 0 and 100`)
+    return false
+  }
+  return true
+}
+
+export function validateAndBuildConfiguration(
+  initConfiguration: InitConfiguration,
+  errorStack?: string
+): Configuration | undefined {
+  if (!initConfiguration || !initConfiguration.clientToken) {
+    display.error('Client Token is not configured, we will not send any data.')
+    return
+  }
+
+  if (
+    initConfiguration.allowedTrackingOrigins !== undefined &&
+    !Array.isArray(initConfiguration.allowedTrackingOrigins)
+  ) {
+    display.error('Allowed Tracking Origins must be an array')
+    return
+  }
+
+  if (
+    // !isKubsesenseSite(initConfiguration.kubesenseRumEndpoint) ||
+    !isSampleRate(initConfiguration.sessionSampleRate, 'Session') ||
+    !isSampleRate(initConfiguration.telemetrySampleRate, 'Telemetry') ||
+    !isSampleRate(initConfiguration.telemetryConfigurationSampleRate, 'Telemetry Configuration') ||
+    !isSampleRate(initConfiguration.telemetryUsageSampleRate, 'Telemetry Usage') ||
+    !isString(initConfiguration.version, 'Version') ||
+    !isString(initConfiguration.env, 'Env') ||
+    !isString(initConfiguration.service, 'Service') ||
+    !isAllowedTrackingOrigins(initConfiguration, errorStack ?? '')
+  ) {
+    return
+  }
+
+  if (
+    initConfiguration.trackingConsent !== undefined &&
+    !objectHasValue(TrackingConsent, initConfiguration.trackingConsent)
+  ) {
+    display.error('Tracking Consent should be either "granted" or "not-granted"')
+    return
+  }
+
+  return {
+    beforeSend:
+      initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),
+    sessionStoreStrategyType: isWorkerEnvironment ? undefined : selectSessionStoreStrategyType(initConfiguration),
+    sessionSampleRate: initConfiguration.sessionSampleRate ?? 100,
+    telemetrySampleRate: initConfiguration.telemetrySampleRate ?? 20,
+    telemetryConfigurationSampleRate: initConfiguration.telemetryConfigurationSampleRate ?? 5,
+    telemetryUsageSampleRate: initConfiguration.telemetryUsageSampleRate ?? 5,
+    service: initConfiguration.service ?? undefined,
+    env: initConfiguration.env ?? undefined,
+    version: initConfiguration.version ?? undefined,
+    datacenter: initConfiguration.datacenter ?? undefined,
+    silentMultipleInit: !!initConfiguration.silentMultipleInit,
+    allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,
+    trackingConsent: initConfiguration.trackingConsent ?? TrackingConsent.GRANTED,
+    trackAnonymousUser: initConfiguration.trackAnonymousUser ?? true,
+    storeContextsAcrossPages: !!initConfiguration.storeContextsAcrossPages,
+    betaEncodeCookieOptions: !!initConfiguration.betaEncodeCookieOptions,
+    /**
+     * The source of the SDK, used for support plugins purposes.
+     */
+    variant: initConfiguration.variant,
+    sdkVersion: initConfiguration.sdkVersion,
+
+    ...computeTransportConfiguration(initConfiguration),
+  }
+}
+
+export function serializeConfiguration(initConfiguration: InitConfiguration) {
+  return {
+    session_sample_rate: initConfiguration.sessionSampleRate,
+    telemetry_sample_rate: initConfiguration.telemetrySampleRate,
+    telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,
+    telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,
+    use_before_send: !!initConfiguration.beforeSend,
+    use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,
+    use_secure_session_cookie: initConfiguration.useSecureSessionCookie,
+    use_proxy: !!initConfiguration.proxy,
+    silent_multiple_init: initConfiguration.silentMultipleInit,
+    track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,
+    track_anonymous_user: initConfiguration.trackAnonymousUser,
+    session_persistence: initConfiguration.sessionPersistence,
+    allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,
+    store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,
+    allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,
+    tracking_consent: initConfiguration.trackingConsent,
+    use_allowed_tracking_origins: Array.isArray(initConfiguration.allowedTrackingOrigins),
+    beta_encode_cookie_options: initConfiguration.betaEncodeCookieOptions,
+    source: initConfiguration.source,
+    sdk_version: initConfiguration.sdkVersion,
+    variant: initConfiguration.variant,
+  } satisfies RawTelemetryConfiguration
+}

package/src/domain/configuration/endpointBuilder.ts

@@ -0,0 +1,105 @@
+import type { Payload } from '../../transport'
+import { timeStampNow } from '../../tools/utils/timeUtils'
+import { normalizeUrl } from '../../tools/utils/urlPolyfill'
+import { generateUUID } from '../../tools/utils/stringUtils'
+import type { InitConfiguration } from './configuration'
+import { INTAKE_SITE_STAGING, INTAKE_SITE_PROD } from '../intakeSites'
+
+// replaced at build time
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+export type TrackType = 'logs' | 'rum' | 'replay' | 'profile' | 'exposures' | 'flagevaluation'
+export type ApiType =
+  | 'fetch-keepalive'
+  | 'fetch'
+  | 'beacon'
+  // 'manual' reflects that the request have been sent manually, outside of the SDK (ex: via curl or
+  // a Node.js script).
+  | 'manual'
+
+export type EndpointBuilder = ReturnType<typeof createEndpointBuilder>
+
+export function createEndpointBuilder(
+  initConfiguration: InitConfiguration,
+  trackType: TrackType,
+  extraParameters?: string[]
+) {
+  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)
+
+  return {
+    build(api: ApiType, payload: Payload) {
+      const parameters = buildEndpointParameters(initConfiguration, trackType, api, payload, extraParameters)
+      return buildUrlWithParameters(parameters)
+    },
+    trackType,
+  }
+}
+
+/**
+ * Create a function used to build a full endpoint url from provided parameters. The goal of this
+ * function is to pre-compute some parts of the URL to avoid re-computing everything on every
+ * request, as only parameters are changing.
+ */
+function createEndpointUrlWithParametersBuilder(
+  initConfiguration: InitConfiguration,
+  trackType: TrackType
+): (parameters: string) => string {
+  const path = `/rum/api/v1/${trackType}`
+  const proxy = initConfiguration.proxy
+  if (typeof proxy === 'string') {
+    const normalizedProxyUrl = normalizeUrl(proxy)
+    return (parameters) => `${normalizedProxyUrl}?kubesense-forward=${encodeURIComponent(`${path}?${parameters}`)}`
+  }
+  if (typeof proxy === 'function') {
+    return (parameters) => proxy({ path, parameters })
+  }
+  const host = initConfiguration.kubesenseRumEndpoint
+  return (parameters) => `https://${host}${path}?${parameters}`
+}
+
+export function buildEndpointHost(
+  trackType: TrackType,
+  initConfiguration: InitConfiguration & { usePciIntake?: boolean }
+) {
+  const { kubesenseRumEndpoint, internalAnalyticsSubdomain } = initConfiguration
+
+  return kubesenseRumEndpoint
+}
+
+/**
+ * Build parameters to be used for an intake request. Parameters should be re-built for each
+ * request, as they change randomly.
+ */
+function buildEndpointParameters(
+  { clientToken, internalAnalyticsSubdomain, source = 'browser'}: InitConfiguration,
+  trackType: TrackType,
+  api: ApiType,
+  { retry, encoding }: Payload,
+  extraParameters: string[] = []
+) {
+  const parameters = [
+    `ksource=${source}`,
+    `kubesense-api-key=${clientToken}`,
+    `kubesense-evp-origin-version=${encodeURIComponent(__BUILD_ENV__SDK_VERSION__)}`,
+    'kubesense-evp-origin=browser',
+    `kubesense-request-id=${generateUUID()}`,
+  ].concat(extraParameters)
+
+  if (encoding) {
+    parameters.push(`kubesense-evp-encoding=${encoding}`)
+  }
+
+  if (trackType === 'rum') {
+    parameters.push(`batch_time=${timeStampNow()}`, `_kubesense.api=${api}`)
+
+    if (retry) {
+      parameters.push(`_kubesense.retry_count=${retry.count}`, `_kubesense.retry_after=${retry.lastFailureStatus}`)
+    }
+  }
+
+  if (internalAnalyticsSubdomain) {
+    parameters.reverse()
+  }
+
+  return parameters.join('&')
+}

package/src/domain/configuration/index.ts

@@ -0,0 +1,12 @@
+export type { Configuration, InitConfiguration, ProxyFn } from './configuration'
+export {
+  DefaultPrivacyLevel,
+  TraceContextInjection,
+  isSampleRate,
+  validateAndBuildConfiguration,
+  serializeConfiguration,
+} from './configuration'
+export type { EndpointBuilder, TrackType } from './endpointBuilder'
+export { createEndpointBuilder, buildEndpointHost } from './endpointBuilder'
+export * from '../intakeSites'
+export { computeTransportConfiguration, isIntakeUrl } from './transportConfiguration'

package/src/domain/configuration/transportConfiguration.ts

@@ -0,0 +1,86 @@
+import type { InitConfiguration } from './configuration'
+import type { EndpointBuilder } from './endpointBuilder'
+import { createEndpointBuilder } from './endpointBuilder'
+// import { buildTags } from './tags'
+import type { Site } from '../intakeSites'
+import { INTAKE_SITE_PROD, INTAKE_URL_PARAMETERS } from '../intakeSites'
+
+export interface TransportConfiguration {
+  logsEndpointBuilder: EndpointBuilder
+  rumEndpointBuilder: EndpointBuilder
+  sessionReplayEndpointBuilder: EndpointBuilder
+  profilingEndpointBuilder: EndpointBuilder
+  exposuresEndpointBuilder: EndpointBuilder
+  flagEvaluationEndpointBuilder: EndpointBuilder
+  datacenter?: string | undefined
+  replica?: ReplicaConfiguration
+  kubesenseRumEndpoint: Site
+  source: 'browser' | 'flutter' | 'unity'
+}
+
+export interface ReplicaConfiguration {
+  logsEndpointBuilder: EndpointBuilder
+  rumEndpointBuilder: EndpointBuilder
+}
+
+export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
+  const site = initConfiguration.kubesenseRumEndpoint || INTAKE_SITE_PROD
+  const source = validateSource(initConfiguration.source)
+
+  // const tags = buildTags(initConfiguration)
+
+  // const endpointBuilders = computeEndpointBuilders(initConfiguration, tags)
+  // const replicaConfiguration = computeReplicaConfiguration(initConfiguration, tags)
+
+  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, kubesenseRumEndpoint: site, source })
+  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, kubesenseRumEndpoint: site, source })
+
+  return {
+    replica: replicaConfiguration,
+    kubesenseRumEndpoint: 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'),
+    flagEvaluationEndpointBuilder: createEndpointBuilder(initConfiguration, 'flagevaluation'),
+  }
+}
+
+function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
+  if (!initConfiguration.replica) {
+    return
+  }
+
+  const replicaConfiguration: InitConfiguration = {
+    ...initConfiguration,
+    kubesenseRumEndpoint: INTAKE_SITE_PROD,
+    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.ts

@@ -0,0 +1,31 @@
+import { globalObject } from '../../tools/globalObject'
+
+export type NetworkInterface = 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | 'unknown'
+export type EffectiveType = 'slow-2g' | '2g' | '3g' | '4g'
+
+interface BrowserNavigator extends Navigator {
+  connection?: NetworkInformation
+}
+
+export interface NetworkInformation {
+  type?: NetworkInterface
+  effectiveType?: EffectiveType
+  saveData: boolean
+}
+
+export interface Connectivity {
+  status: 'connected' | 'not_connected'
+  interfaces?: NetworkInterface[]
+  effective_type?: EffectiveType
+  [key: string]: unknown
+}
+
+export function getConnectivity(): Connectivity {
+  const navigator = globalObject.navigator as BrowserNavigator
+  
+  return {
+    status: navigator.onLine ? 'connected' : 'not_connected',
+    interfaces: navigator.connection && navigator.connection.type ? [navigator.connection.type] : ['unknown'],
+    effective_type: navigator.connection?.effectiveType,
+  }
+}

package/src/domain/connectivity/index.ts

@@ -0,0 +1 @@
+export * from './connectivity'