@openobserve/browser-core 0.2.11 → 0.2.12-beta.13

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

@@ -1,23 +1,46 @@
+import { isEmptyObject } from '../../../tools/utils/objectUtils'
+import { isChromium } from '../../../tools/utils/browserDetection'
 import type { CookieOptions } from '../../../browser/cookie'
-import { getCurrentSite, areCookiesAuthorized, deleteCookie, getCookie, setCookie } from '../../../browser/cookie'
-import type { InitConfiguration } from '../../configuration'
+import { getCurrentSite, areCookiesAuthorized, getCookies, setCookie, getCookie } from '../../../browser/cookie'
+import type { InitConfiguration, Configuration } from '../../configuration'
 import { tryOldCookiesMigration } from '../oldCookiesMigration'
-import { SESSION_EXPIRATION_DELAY } from '../sessionConstants'
+import {
+  SESSION_COOKIE_EXPIRATION_DELAY,
+  SESSION_EXPIRATION_DELAY,
+  SESSION_TIME_OUT_DELAY,
+  SessionPersistence,
+} from '../sessionConstants'
 import type { SessionState } from '../sessionState'
-import { toSessionString, toSessionState } from '../sessionState'
+import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
 import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
 import { SESSION_STORE_KEY } from './sessionStoreStrategy'
 
+const SESSION_COOKIE_VERSION = 0
+
 export function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {
   const cookieOptions = buildCookieOptions(initConfiguration)
-  return areCookiesAuthorized(cookieOptions) ? { type: 'Cookie', cookieOptions } : undefined
+  return cookieOptions && areCookiesAuthorized(cookieOptions)
+    ? { type: SessionPersistence.COOKIE, cookieOptions }
+    : undefined
 }
 
-export function initCookieStrategy(cookieOptions: CookieOptions): SessionStoreStrategy {
+export function initCookieStrategy(configuration: Configuration, cookieOptions: CookieOptions): SessionStoreStrategy {
   const cookieStore = {
-    persistSession: persistSessionCookie(cookieOptions),
-    retrieveSession: retrieveSessionCookie,
-    clearSession: deleteSessionCookie(cookieOptions),
+    /**
+     * 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(cookieOptions, configuration),
+    expireSession: (sessionState: SessionState) =>
+      storeSessionCookie(
+        cookieOptions,
+        configuration,
+        getExpiredSessionState(sessionState, configuration),
+        SESSION_TIME_OUT_DELAY
+      ),
   }
 
   tryOldCookiesMigration(cookieStore)
@@ -25,32 +48,99 @@ export function initCookieStrategy(cookieOptions: CookieOptions): SessionStoreSt
   return cookieStore
 }
 
-function persistSessionCookie(options: CookieOptions) {
-  return (session: SessionState) => {
-    setCookie(SESSION_STORE_KEY, toSessionString(session), SESSION_EXPIRATION_DELAY, options)
+function storeSessionCookie(
+  options: CookieOptions,
+  configuration: Configuration,
+  sessionState: SessionState,
+  defaultTimeout: number
+) {
+  let sessionStateString = toSessionString(sessionState)
+
+  if (configuration.betaEncodeCookieOptions) {
+    sessionStateString = toSessionString({
+      ...sessionState,
+      // deleting a cookie is writing a new cookie with an empty value
+      // we don't want to store the cookie options in this case otherwise the cookie will not be deleted
+      ...(!isEmptyObject(sessionState) ? { c: encodeCookieOptions(options) } : {}),
+    })
   }
-}
 
-function retrieveSessionCookie(): SessionState {
-  const sessionString = getCookie(SESSION_STORE_KEY)
-  return toSessionState(sessionString)
+  setCookie(
+    SESSION_STORE_KEY,
+    sessionStateString,
+    configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout,
+    options
+  )
 }
 
-function deleteSessionCookie(options: CookieOptions) {
-  return () => {
-    deleteCookie(SESSION_STORE_KEY, options)
+/**
+ * Retrieve the session state from the cookie that was set with the same cookie options
+ * If there is no match, return the first cookie, because that's how `getCookie()` works
+ */
+export function retrieveSessionCookie(cookieOptions: CookieOptions, configuration: Configuration): SessionState {
+  if (configuration.betaEncodeCookieOptions) {
+    return retrieveSessionCookieFromEncodedCookie(cookieOptions)
   }
+
+  const sessionString = getCookie(SESSION_STORE_KEY)
+  const sessionState = toSessionState(sessionString)
+  return sessionState
 }
 
-export function buildCookieOptions(initConfiguration: InitConfiguration) {
+export function buildCookieOptions(initConfiguration: InitConfiguration): CookieOptions | undefined {
   const cookieOptions: CookieOptions = {}
 
-  cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
-  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.secure =
+    !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie
+  cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie
+  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie
 
   if (initConfiguration.trackSessionAcrossSubdomains) {
-    cookieOptions.domain = getCurrentSite()
+    const currentSite = getCurrentSite()
+    if (!currentSite) {
+      return
+    }
+    cookieOptions.domain = currentSite
   }
 
   return cookieOptions
 }
+
+function encodeCookieOptions(cookieOptions: CookieOptions): string {
+  const domainCount = cookieOptions.domain ? cookieOptions.domain.split('.').length - 1 : 0
+
+  /* eslint-disable no-bitwise */
+  let byte = 0
+  byte |= SESSION_COOKIE_VERSION << 5 // Store version in upper 3 bits
+  byte |= domainCount << 1 // Store domain count in next 4 bits
+  byte |= cookieOptions.crossSite ? 1 : 0 // Store useCrossSiteScripting in next bit
+  /* eslint-enable no-bitwise */
+
+  return byte.toString(16) // Convert to hex string
+}
+
+/**
+ * Retrieve the session state from the cookie that was set with the same cookie options.
+ * If there is no match, fallback to the first cookie, (because that's how `getCookie()` works)
+ * and this allows to keep the current session id when we release this feature.
+ */
+function retrieveSessionCookieFromEncodedCookie(cookieOptions: CookieOptions): SessionState {
+  const cookies = getCookies(SESSION_STORE_KEY)
+  const opts = encodeCookieOptions(cookieOptions)
+
+  let sessionState: SessionState | undefined
+
+  // reverse the cookies so that if there is no match, the cookie returned is the first one
+  for (const cookie of cookies.reverse()) {
+    sessionState = toSessionState(cookie)
+
+    if (sessionState.c === opts) {
+      break
+    }
+  }
+
+  // remove the cookie options from the session state as this is not part of the session state
+  delete sessionState?.c
+
+  return sessionState ?? {}
+}

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

@@ -1,6 +1,8 @@
 import { generateUUID } from '../../../tools/utils/stringUtils'
+import type { Configuration } from '../../configuration'
+import { SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
-import { toSessionString, toSessionState } from '../sessionState'
+import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
 import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
 import { SESSION_STORE_KEY } from './sessionStoreStrategy'
 
@@ -13,17 +15,18 @@ export function selectLocalStorageStrategy(): SessionStoreStrategyType | undefin
     localStorage.setItem(testKey, id)
     const retrievedId = localStorage.getItem(testKey)
     localStorage.removeItem(testKey)
-    return id === retrievedId ? { type: 'LocalStorage' } : undefined
-  } catch (e) {
+    return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : undefined
+  } catch {
     return undefined
   }
 }
 
-export function initLocalStorageStrategy(): SessionStoreStrategy {
+export function initLocalStorageStrategy(configuration: Configuration): SessionStoreStrategy {
   return {
+    isLockEnabled: false,
     persistSession: persistInLocalStorage,
     retrieveSession: retrieveSessionFromLocalStorage,
-    clearSession: clearSessionFromLocalStorage,
+    expireSession: (sessionState: SessionState) => expireSessionFromLocalStorage(sessionState, configuration),
   }
 }
 
@@ -31,11 +34,11 @@ function persistInLocalStorage(sessionState: SessionState) {
   localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
 }
 
-function retrieveSessionFromLocalStorage(): SessionState {
+export function retrieveSessionFromLocalStorage(): SessionState {
   const sessionString = localStorage.getItem(SESSION_STORE_KEY)
   return toSessionState(sessionString)
 }
 
-function clearSessionFromLocalStorage() {
-  localStorage.removeItem(SESSION_STORE_KEY)
+function expireSessionFromLocalStorage(previousSessionState: SessionState, configuration: Configuration) {
+  persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration))
 }

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

@@ -1,12 +1,16 @@
 import type { CookieOptions } from '../../../browser/cookie'
+import type { SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
 
 export const SESSION_STORE_KEY = '_oo_s'
 
-export type SessionStoreStrategyType = { type: 'Cookie'; cookieOptions: CookieOptions } | { type: 'LocalStorage' }
+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
-  clearSession: () => void
+  expireSession: (previousSessionState: SessionState) => void
 }

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -1,4 +1,5 @@
-import { getCookie } from '../../browser/cookie'
+import { getInitCookie } from '../../browser/cookie'
+import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
 
 export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'openobserve-synthetics-public-id'
 export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'openobserve-synthetics-result-id'
@@ -11,17 +12,27 @@ export interface BrowserWindow extends Window {
 }
 
 export function willSyntheticsInjectRum(): boolean {
+  if (isWorkerEnvironment) {
+    // We don't expect to run synthetics tests in a worker environment
+    return false
+  }
+
   return Boolean(
-    (window as BrowserWindow)._OO_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+    (globalObject as BrowserWindow)._OO_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
   )
 }
 
 export function getSyntheticsTestId(): string | undefined {
-  const value = (window as BrowserWindow)._OO_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  const value = (window as BrowserWindow)._OO_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)._OO_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+  const value =
+    (window as BrowserWindow)._OO_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

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

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

@@ -1,8 +1,9 @@
-import type { TelemetryEvent, TelemetryConfigurationEvent } from './telemetryEvent.types'
+import type { TelemetryEvent, TelemetryConfigurationEvent, TelemetryUsageEvent } from './telemetryEvent.types'
 
 export const TelemetryType = {
-  log: 'log',
-  configuration: 'configuration',
+  LOG: 'log',
+  CONFIGURATION: 'configuration',
+  USAGE: 'usage',
 } as const
 
 export const enum StatusType {
@@ -10,5 +11,12 @@ export const enum StatusType {
   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']