@pratham.raval/browser-core 6.22.3

package/src/domain/session/sessionStore.ts

@@ -0,0 +1,244 @@
+import { clearInterval, setInterval } from '../../tools/timer'
+import { Observable } from '../../tools/observable'
+import { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils'
+import { throttle } from '../../tools/utils/functionUtils'
+import { generateUUID } from '../../tools/utils/stringUtils'
+import type { InitConfiguration, Configuration } from '../configuration'
+import { display } from '../../tools/display'
+import { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'
+import type { SessionStoreStrategy, SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'
+import type { SessionState } from './sessionState'
+import {
+  getExpiredSessionState,
+  isSessionInExpiredState,
+  isSessionInNotStartedState,
+  isSessionStarted,
+} from './sessionState'
+import { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'
+import { processSessionStoreOperations } from './sessionStoreOperations'
+import { SESSION_NOT_TRACKED, SessionPersistence } from './sessionConstants'
+
+export interface SessionStore {
+  expandOrRenewSession: () => void
+  expandSession: () => void
+  getSession: () => SessionState
+  restartSession: () => void
+  renewObservable: Observable<void>
+  expireObservable: Observable<void>
+  sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
+  expire: () => void
+  stop: () => void
+  updateSessionState: (state: Partial<SessionState>) => void
+}
+
+/**
+ * Every second, the storage will be polled to check for any change that can occur
+ * to the session state in another browser tab, or another window.
+ * This value has been determined from our previous cookie-only implementation.
+ */
+export const STORAGE_POLL_DELAY = ONE_SECOND
+
+/**
+ * Selects the correct session store strategy type based on the configuration and storage
+ * availability.
+ */
+export function selectSessionStoreStrategyType(
+  initConfiguration: InitConfiguration
+): SessionStoreStrategyType | undefined {
+  switch (initConfiguration.sessionPersistence) {
+    case SessionPersistence.COOKIE:
+      return selectCookieStrategy(initConfiguration)
+
+    case SessionPersistence.LOCAL_STORAGE:
+      return selectLocalStorageStrategy()
+
+    case undefined: {
+      let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
+      if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
+        sessionStoreStrategyType = selectLocalStorageStrategy()
+      }
+      return sessionStoreStrategyType
+    }
+
+    default:
+      display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`)
+  }
+}
+
+export function getSessionStoreStrategy(
+  sessionStoreStrategyType: SessionStoreStrategyType,
+  configuration: Configuration
+) {
+  return sessionStoreStrategyType.type === SessionPersistence.COOKIE
+    ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)
+    : initLocalStorageStrategy(configuration)
+}
+
+/**
+ * Different session concepts:
+ * - tracked, the session has an id and is updated along the user navigation
+ * - not tracked, the session does not have an id but it is updated along the user navigation
+ * - inactive, no session in store or session expired, waiting for a renew session
+ */
+export function startSessionStore<TrackingType extends string>(
+  sessionStoreStrategyType: SessionStoreStrategyType,
+  configuration: Configuration,
+  productKey: string,
+  computeTrackingType: (rawTrackingType?: string) => TrackingType,
+  sessionStoreStrategy: SessionStoreStrategy = getSessionStoreStrategy(sessionStoreStrategyType, configuration)
+): SessionStore {
+  const renewObservable = new Observable<void>()
+  const expireObservable = new Observable<void>()
+  const sessionStateUpdateObservable = new Observable<{ previousState: SessionState; newState: SessionState }>()
+
+  const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)
+  let sessionCache: SessionState
+
+  startSession()
+
+  const { throttled: throttledExpandOrRenewSession, cancel: cancelExpandOrRenewSession } = throttle(() => {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => {
+          if (isSessionInNotStartedState(sessionState)) {
+            return
+          }
+
+          const synchronizedSession = synchronizeSession(sessionState)
+          expandOrRenewSessionState(synchronizedSession)
+          return synchronizedSession
+        },
+        after: (sessionState) => {
+          if (isSessionStarted(sessionState) && !hasSessionInCache()) {
+            renewSessionInCache(sessionState)
+          }
+          sessionCache = sessionState
+        },
+      },
+      sessionStoreStrategy
+    )
+  }, STORAGE_POLL_DELAY)
+
+  function expandSession() {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => (hasSessionInCache() ? synchronizeSession(sessionState) : undefined),
+      },
+      sessionStoreStrategy
+    )
+  }
+
+  /**
+   * allows two behaviors:
+   * - if the session is active, synchronize the session cache without updating the session store
+   * - if the session is not active, clear the session store and expire the session cache
+   */
+  function watchSession() {
+    const sessionState = sessionStoreStrategy.retrieveSession()
+
+    if (isSessionInExpiredState(sessionState)) {
+      processSessionStoreOperations(
+        {
+          process: (sessionState: SessionState) =>
+            isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,
+          after: synchronizeSession,
+        },
+        sessionStoreStrategy
+      )
+    } else {
+      synchronizeSession(sessionState)
+    }
+  }
+
+  function synchronizeSession(sessionState: SessionState) {
+    if (isSessionInExpiredState(sessionState)) {
+      sessionState = getExpiredSessionState(sessionState, configuration)
+    }
+    if (hasSessionInCache()) {
+      if (isSessionInCacheOutdated(sessionState)) {
+        expireSessionInCache()
+      } else {
+        sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState })
+        sessionCache = sessionState
+      }
+    }
+    return sessionState
+  }
+
+  function startSession() {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => {
+          if (isSessionInNotStartedState(sessionState)) {
+            return getExpiredSessionState(sessionState, configuration)
+          }
+        },
+        after: (sessionState) => {
+          sessionCache = sessionState
+        },
+      },
+      sessionStoreStrategy
+    )
+  }
+
+  function expandOrRenewSessionState(sessionState: SessionState) {
+    if (isSessionInNotStartedState(sessionState)) {
+      return false
+    }
+
+    const trackingType = computeTrackingType(sessionState[productKey])
+    sessionState[productKey] = trackingType
+    delete sessionState.isExpired
+    if (trackingType !== SESSION_NOT_TRACKED && !sessionState.id) {
+      sessionState.id = generateUUID()
+      sessionState.created = String(dateNow())
+    }
+  }
+
+  function hasSessionInCache() {
+    return sessionCache?.[productKey] !== undefined
+  }
+
+  function isSessionInCacheOutdated(sessionState: SessionState) {
+    return sessionCache.id !== sessionState.id || sessionCache[productKey] !== sessionState[productKey]
+  }
+
+  function expireSessionInCache() {
+    sessionCache = getExpiredSessionState(sessionCache, configuration)
+    expireObservable.notify()
+  }
+
+  function renewSessionInCache(sessionState: SessionState) {
+    sessionCache = sessionState
+    renewObservable.notify()
+  }
+
+  function updateSessionState(partialSessionState: Partial<SessionState>) {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => ({ ...sessionState, ...partialSessionState }),
+        after: synchronizeSession,
+      },
+      sessionStoreStrategy
+    )
+  }
+
+  return {
+    expandOrRenewSession: throttledExpandOrRenewSession,
+    expandSession,
+    getSession: () => sessionCache,
+    renewObservable,
+    expireObservable,
+    sessionStateUpdateObservable,
+    restartSession: startSession,
+    expire: () => {
+      cancelExpandOrRenewSession()
+      sessionStoreStrategy.expireSession(sessionCache)
+      synchronizeSession(getExpiredSessionState(sessionCache, configuration))
+    },
+    stop: () => {
+      clearInterval(watchSessionTimeoutId)
+    },
+    updateSessionState,
+  }
+}

package/src/domain/session/sessionStoreOperations.ts

@@ -0,0 +1,131 @@
+import { setTimeout } from '../../tools/timer'
+import { generateUUID } from '../../tools/utils/stringUtils'
+import type { TimeStamp } from '../../tools/utils/timeUtils'
+import { elapsed, ONE_SECOND, timeStampNow } from '../../tools/utils/timeUtils'
+import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
+import type { SessionState } from './sessionState'
+import { expandSessionState, isSessionInExpiredState } from './sessionState'
+
+interface Operations {
+  process: (sessionState: SessionState) => SessionState | undefined
+  after?: (sessionState: SessionState) => void
+}
+
+export const LOCK_RETRY_DELAY = 10
+export const LOCK_MAX_TRIES = 100
+
+// Locks should be hold for a few milliseconds top, just the time it takes to read and write a
+// cookie. Using one second should be enough in most situations.
+export const LOCK_EXPIRATION_DELAY = ONE_SECOND
+const LOCK_SEPARATOR = '--'
+
+const bufferedOperations: Operations[] = []
+let ongoingOperations: Operations | undefined
+
+export function processSessionStoreOperations(
+  operations: Operations,
+  sessionStoreStrategy: SessionStoreStrategy,
+  numberOfRetries = 0
+) {
+  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
+  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })
+  const retrieveStore = () => {
+    const { lock, ...session } = sessionStoreStrategy.retrieveSession()
+    return {
+      session,
+      lock: lock && !isLockExpired(lock) ? lock : undefined,
+    }
+  }
+
+  if (!ongoingOperations) {
+    ongoingOperations = operations
+  }
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations)
+    return
+  }
+  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+    next(sessionStoreStrategy)
+    return
+  }
+  let currentLock: string
+  let currentStore = retrieveStore()
+  if (isLockEnabled) {
+    // if someone has lock, retry later
+    if (currentStore.lock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+    // acquire lock
+    currentLock = createLock()
+    persistWithLock(currentStore.session)
+    // if lock is not acquired, retry later
+    currentStore = retrieveStore()
+    if (currentStore.lock !== currentLock) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+  }
+  let processedSession = operations.process(currentStore.session)
+  if (isLockEnabled) {
+    // if lock corrupted after process, retry later
+    currentStore = retrieveStore()
+    if (currentStore.lock !== currentLock!) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+  }
+  if (processedSession) {
+    if (isSessionInExpiredState(processedSession)) {
+      expireSession(processedSession)
+    } else {
+      expandSessionState(processedSession)
+      if (isLockEnabled) {
+        persistWithLock(processedSession)
+      } else {
+        persistSession(processedSession)
+      }
+    }
+  }
+  if (isLockEnabled) {
+    // correctly handle lock around expiration would require to handle this case properly at several levels
+    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
+    if (!(processedSession && isSessionInExpiredState(processedSession))) {
+      // if lock corrupted after persist, retry later
+      currentStore = retrieveStore()
+      if (currentStore.lock !== currentLock!) {
+        retryLater(operations, sessionStoreStrategy, numberOfRetries)
+        return
+      }
+      persistSession(currentStore.session)
+      processedSession = currentStore.session
+    }
+  }
+  // call after even if session is not persisted in order to perform operations on
+  // up-to-date session state value => the value could have been modified by another tab
+  operations.after?.(processedSession || currentStore.session)
+  next(sessionStoreStrategy)
+}
+
+function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
+  setTimeout(() => {
+    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)
+  }, LOCK_RETRY_DELAY)
+}
+
+function next(sessionStore: SessionStoreStrategy) {
+  ongoingOperations = undefined
+  const nextOperations = bufferedOperations.shift()
+  if (nextOperations) {
+    processSessionStoreOperations(nextOperations, sessionStore)
+  }
+}
+
+export function createLock(): string {
+  return generateUUID() + LOCK_SEPARATOR + timeStampNow()
+}
+
+function isLockExpired(lock: string) {
+  const [, timeStamp] = lock.split(LOCK_SEPARATOR)
+  return !timeStamp || elapsed(Number(timeStamp) as TimeStamp, timeStampNow()) > LOCK_EXPIRATION_DELAY
+}

package/src/domain/session/storeStrategies/sessionInCookie.ts

@@ -0,0 +1,85 @@
+import { isChromium } from '../../../tools/utils/browserDetection'
+import type { CookieOptions } from '../../../browser/cookie'
+import { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie'
+import type { InitConfiguration, Configuration } from '../../configuration'
+import { tryOldCookiesMigration } from '../oldCookiesMigration'
+import {
+  SESSION_COOKIE_EXPIRATION_DELAY,
+  SESSION_EXPIRATION_DELAY,
+  SESSION_TIME_OUT_DELAY,
+  SessionPersistence,
+} from '../sessionConstants'
+import type { SessionState } from '../sessionState'
+import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
+import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+import { SESSION_STORE_KEY } from './sessionStoreStrategy'
+
+export function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {
+  const cookieOptions = buildCookieOptions(initConfiguration)
+  return cookieOptions && areCookiesAuthorized(cookieOptions)
+    ? { type: SessionPersistence.COOKIE, cookieOptions }
+    : undefined
+}
+
+export function initCookieStrategy(configuration: Configuration, cookieOptions: CookieOptions): SessionStoreStrategy {
+  const cookieStore = {
+    /**
+     * Lock strategy allows mitigating issues due to concurrent access to cookie.
+     * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.
+     */
+    isLockEnabled: isChromium(),
+    persistSession: (sessionState: SessionState) =>
+      storeSessionCookie(cookieOptions, configuration, sessionState, SESSION_EXPIRATION_DELAY),
+    retrieveSession: retrieveSessionCookie,
+    expireSession: (sessionState: SessionState) =>
+      storeSessionCookie(
+        cookieOptions,
+        configuration,
+        getExpiredSessionState(sessionState, configuration),
+        SESSION_TIME_OUT_DELAY
+      ),
+  }
+
+  tryOldCookiesMigration(cookieStore)
+
+  return cookieStore
+}
+
+function storeSessionCookie(
+  options: CookieOptions,
+  configuration: Configuration,
+  sessionState: SessionState,
+  defaultTimeout: number
+) {
+  setCookie(
+    SESSION_STORE_KEY,
+    toSessionString(sessionState),
+    configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout,
+    options
+  )
+}
+
+export function retrieveSessionCookie(): SessionState {
+  const sessionString = getCookie(SESSION_STORE_KEY)
+  const sessionState = toSessionState(sessionString)
+  return sessionState
+}
+
+export function buildCookieOptions(initConfiguration: InitConfiguration): CookieOptions | undefined {
+  const cookieOptions: CookieOptions = {}
+
+  cookieOptions.secure =
+    !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie
+  cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie
+  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    const currentSite = getCurrentSite()
+    if (!currentSite) {
+      return
+    }
+    cookieOptions.domain = currentSite
+  }
+
+  return cookieOptions
+}

package/src/domain/session/storeStrategies/sessionInLocalStorage.ts

@@ -0,0 +1,44 @@
+import { generateUUID } from '../../../tools/utils/stringUtils'
+import type { Configuration } from '../../configuration'
+import { SessionPersistence } from '../sessionConstants'
+import type { SessionState } from '../sessionState'
+import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
+import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+import { SESSION_STORE_KEY } from './sessionStoreStrategy'
+
+const LOCAL_STORAGE_TEST_KEY = '_dd_test_'
+
+export function selectLocalStorageStrategy(): SessionStoreStrategyType | undefined {
+  try {
+    const id = generateUUID()
+    const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`
+    localStorage.setItem(testKey, id)
+    const retrievedId = localStorage.getItem(testKey)
+    localStorage.removeItem(testKey)
+    return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export function initLocalStorageStrategy(configuration: Configuration): SessionStoreStrategy {
+  return {
+    isLockEnabled: false,
+    persistSession: persistInLocalStorage,
+    retrieveSession: retrieveSessionFromLocalStorage,
+    expireSession: (sessionState: SessionState) => expireSessionFromLocalStorage(sessionState, configuration),
+  }
+}
+
+function persistInLocalStorage(sessionState: SessionState) {
+  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
+}
+
+function retrieveSessionFromLocalStorage(): SessionState {
+  const sessionString = localStorage.getItem(SESSION_STORE_KEY)
+  return toSessionState(sessionString)
+}
+
+function expireSessionFromLocalStorage(previousSessionState: SessionState, configuration: Configuration) {
+  persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration))
+}

package/src/domain/session/storeStrategies/sessionStoreStrategy.ts

@@ -0,0 +1,16 @@
+import type { CookieOptions } from '../../../browser/cookie'
+import type { SessionPersistence } from '../sessionConstants'
+import type { SessionState } from '../sessionState'
+
+export const SESSION_STORE_KEY = '_dd_s'
+
+export type SessionStoreStrategyType =
+  | { type: typeof SessionPersistence.COOKIE; cookieOptions: CookieOptions }
+  | { type: typeof SessionPersistence.LOCAL_STORAGE }
+
+export interface SessionStoreStrategy {
+  isLockEnabled: boolean
+  persistSession: (session: SessionState) => void
+  retrieveSession: () => SessionState
+  expireSession: (previousSessionState: SessionState) => void
+}

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -0,0 +1,38 @@
+import { getInitCookie } from '../../browser/cookie'
+import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
+
+export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id'
+export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id'
+export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum'
+
+export interface BrowserWindow extends Window {
+  _DATADOG_SYNTHETICS_PUBLIC_ID?: unknown
+  _DATADOG_SYNTHETICS_RESULT_ID?: unknown
+  _DATADOG_SYNTHETICS_INJECTS_RUM?: unknown
+}
+
+export function willSyntheticsInjectRum(): boolean {
+  if (isWorkerEnvironment) {
+    // We don't expect to run synthetics tests in a worker environment
+    return false
+  }
+
+  return Boolean(
+    (globalObject as BrowserWindow)._DATADOG_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+  )
+}
+
+export function getSyntheticsTestId(): string | undefined {
+  const value = (window as BrowserWindow)._DATADOG_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  return typeof value === 'string' ? value : undefined
+}
+
+export function getSyntheticsResultId(): string | undefined {
+  const value =
+    (window as BrowserWindow)._DATADOG_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+  return typeof value === 'string' ? value : undefined
+}
+
+export function isSyntheticsTest(): boolean {
+  return Boolean(getSyntheticsTestId() && getSyntheticsResultId())
+}

package/src/domain/tags.ts

@@ -0,0 +1,76 @@
+import { DOCS_ORIGIN, MORE_DETAILS, display } from '../tools/display'
+import type { Configuration } from './configuration'
+
+export const TAG_SIZE_LIMIT = 200
+
+// replaced at build time
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+export function buildTags(configuration: Configuration): string[] {
+  const { env, service, version, datacenter, sdkVersion, variant } = configuration
+  const tags = [buildTag('sdk_version', sdkVersion ?? __BUILD_ENV__SDK_VERSION__)]
+
+  if (env) {
+    tags.push(buildTag('env', env))
+  }
+  if (service) {
+    tags.push(buildTag('service', service))
+  }
+  if (version) {
+    tags.push(buildTag('version', version))
+  }
+  if (datacenter) {
+    tags.push(buildTag('datacenter', datacenter))
+  }
+
+  if (variant) {
+    tags.push(buildTag('variant', variant))
+  }
+
+  return tags
+}
+
+export function buildTag(key: string, rawValue?: string) {
+  // See https://docs.datadoghq.com/getting_started/tagging/#defining-tags for tags syntax. Note
+  // that the backend may not follow the exact same rules, so we only want to display an informal
+  // warning.
+  const tag = rawValue ? `${key}:${rawValue}` : key
+
+  if (tag.length > TAG_SIZE_LIMIT || hasForbiddenCharacters(tag)) {
+    display.warn(
+      `Tag ${tag} doesn't meet tag requirements and will be sanitized. ${MORE_DETAILS} ${DOCS_ORIGIN}/getting_started/tagging/#defining-tags`
+    )
+  }
+
+  // Let the backend do most of the sanitization, but still make sure multiple tags can't be crafted
+  // by forging a value containing commas.
+  return sanitizeTag(tag)
+}
+
+export function sanitizeTag(tag: string) {
+  return tag.replace(/,/g, '_')
+}
+
+function hasForbiddenCharacters(rawValue: string) {
+  // Unicode property escapes is not supported in all browsers, so we use a try/catch.
+  // Todo: Remove the try/catch when dropping support for Chrome 63 and Firefox 67
+  // see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#browser_compatibility
+  if (!supportUnicodePropertyEscapes()) {
+    return false
+  }
+
+  // We use the Unicode property escapes to match any character that is a letter including other languages like Chinese, Japanese, etc.
+  // p{Ll} matches a lowercase letter.
+  // p{Lo} matches a letter that is neither uppercase nor lowercase (ex: Japanese characters).
+  // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Unicode_character_class_escape#unicode_property_escapes_vs._character_classes
+  return new RegExp('[^\\p{Ll}\\p{Lo}0-9_:./-]', 'u').test(rawValue)
+}
+
+export function supportUnicodePropertyEscapes() {
+  try {
+    new RegExp('[\\p{Ll}]', 'u')
+    return true
+  } catch {
+    return false
+  }
+}

package/src/domain/telemetry/index.ts

@@ -0,0 +1,22 @@
+export type { Telemetry } from './telemetry'
+export {
+  TelemetryService,
+  TelemetryMetrics,
+  addTelemetryDebug,
+  addTelemetryError,
+  resetTelemetry,
+  startTelemetry,
+  addTelemetryConfiguration,
+  addTelemetryUsage,
+  addTelemetryMetrics,
+  getTelemetryObservable,
+} from './telemetry'
+
+export * from './rawTelemetryEvent.types'
+export type {
+  TelemetryEvent,
+  TelemetryErrorEvent,
+  TelemetryDebugEvent,
+  TelemetryConfigurationEvent,
+  TelemetryUsageEvent,
+} from './telemetryEvent.types'

package/src/domain/telemetry/rawTelemetryEvent.types.ts

@@ -0,0 +1,22 @@
+import type { TelemetryEvent, TelemetryConfigurationEvent, TelemetryUsageEvent } from './telemetryEvent.types'
+
+export const TelemetryType = {
+  LOG: 'log',
+  CONFIGURATION: 'configuration',
+  USAGE: 'usage',
+} as const
+
+export const enum StatusType {
+  debug = 'debug',
+  error = 'error',
+}
+
+export interface RuntimeEnvInfo {
+  is_local_file: boolean
+  is_worker: boolean
+}
+
+export type RawTelemetryEvent = TelemetryEvent['telemetry']
+export type RawTelemetryConfiguration = TelemetryConfigurationEvent['telemetry']['configuration']
+export type RawTelemetryUsage = TelemetryUsageEvent['telemetry']['usage']
+export type RawTelemetryUsageFeature = TelemetryUsageEvent['telemetry']['usage']['feature']