@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

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

@@ -1,109 +1,150 @@
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
 import { isEmptyObject } from '../../../tools/utils/objectUtils'
-import { isChromium } from '../../../tools/utils/browserDetection'
 import type { CookieOptions } from '../../../browser/cookie'
-import { getCurrentSite, areCookiesAuthorized, getCookies, setCookie, getCookie } 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 { getCookies } from '../../../browser/cookie'
+import type { Configuration } from '../../configuration'
+import { buildCookieOptions } from '../../configuration'
+import { SESSION_COOKIE_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'
+import { toSessionString, toSessionState } from '../sessionState'
+import { Observable } from '../../../tools/observable'
+import { mockable } from '../../../tools/mockable'
+import type { CookieAccess } from '../../../browser/cookieAccess'
+import {
+  areCookiesAuthorized,
+  createCookieStoreAccess,
+  createDocumentCookieAccess,
+  isCookieStoreSupported,
+} from '../../../browser/cookieAccess'
+import { CookieApi, LEGACY_SESSION_STORE_KEY, SESSION_STORE_KEY } from './sessionStoreStrategy'
+import type {
+  SessionStoreStrategy,
+  SessionStoreStrategyType,
+  CookieSessionStoreStrategyType,
+  SessionStateOperation,
+} from './sessionStoreStrategy'
 
 const SESSION_COOKIE_VERSION = 0
 
-export function selectCookieStrategy(initConfiguration: InitConfiguration): SessionStoreStrategyType | undefined {
-  const cookieOptions = buildCookieOptions(initConfiguration)
-  return cookieOptions && areCookiesAuthorized(cookieOptions)
-    ? { type: SessionPersistence.COOKIE, cookieOptions }
-    : undefined
-}
+export async function selectCookieStrategy(
+  configuration: Configuration
+): Promise<SessionStoreStrategyType | undefined> {
+  const cookieOptions = buildCookieOptions(configuration)
+  if (!cookieOptions) {
+    return 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(cookieOptions, configuration),
-    expireSession: (sessionState: SessionState) =>
-      storeSessionCookie(
-        cookieOptions,
-        configuration,
-        getExpiredSessionState(sessionState, configuration),
-        SESSION_TIME_OUT_DELAY
-      ),
+  if (isCookieStoreSupported() && (await areCookiesAuthorized(createCookieStoreAccess, cookieOptions))) {
+    return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.COOKIE_STORE }
   }
 
-  tryOldCookiesMigration(cookieStore)
+  if (await areCookiesAuthorized(createDocumentCookieAccess, cookieOptions)) {
+    return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.DOCUMENT_COOKIE }
+  }
 
-  return cookieStore
+  return undefined
 }
 
-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) } : {}),
+// Promise chain serializes calls when Web Locks are unavailable
+let pendingChain: Promise<void> | undefined
+
+export function initCookieStrategy(
+  sessionStoreStrategyType: CookieSessionStoreStrategyType,
+  configuration: Configuration
+): SessionStoreStrategy {
+  const { cookieOptions, cookieApi } = sessionStoreStrategyType
+  const sessionObservable = new Observable<SessionState>()
+  const trackAnonymousUser = !!configuration.trackAnonymousUser
+  const opts = encodeCookieOptions(cookieOptions)
+  const cookieAccess = mockable(createCookieAccess)(cookieApi, cookieOptions)
+  let isFirstCall = true
+
+  cookieAccess.observable.subscribe(() => {
+    cookieAccess
+      .getAll()
+      .then((cookieValues) => {
+        sessionObservable.notify(findMatchingSessionState(cookieValues, opts))
+      })
+      .catch((error) => monitorError(new Error(`Error while reading session cookies on change: ${error}`)))
+  })
+
+  function applyAndWrite(fn: (state: SessionState) => SessionState) {
+    return cookieAccess.getAllAndSet((cookieValues) => {
+      let currentState = findMatchingSessionState(cookieValues, opts)
+
+      if (isFirstCall && isEmptyObject(currentState)) {
+        currentState = findMatchingSessionState(getCookies(LEGACY_SESSION_STORE_KEY), opts)
+      }
+      isFirstCall = false
+
+      const newState = fn(currentState)
+      const sessionString = buildSessionString(newState, cookieOptions)
+      const expireDelay = trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : SESSION_TIME_OUT_DELAY
+
+      return { value: sessionString, expireDelay }
     })
   }
 
-  setCookie(
-    SESSION_STORE_KEY,
-    sessionStateString,
-    configuration.trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : defaultTimeout,
-    options
-  )
+  return {
+    async setSessionState(
+      fn: (sessionState: SessionState) => SessionState,
+      _operation: SessionStateOperation
+    ): Promise<void> {
+      if (typeof navigator !== 'undefined' && navigator.locks) {
+        await navigator.locks
+          .request(SESSION_STORE_KEY, () => applyAndWrite(fn))
+          .catch((error: unknown) => {
+            if (isContextGoingAwayError(error)) {
+              return
+            }
+            throw error
+          })
+      } else {
+        pendingChain = (pendingChain ?? Promise.resolve()).then(() => applyAndWrite(fn))
+        await pendingChain
+      }
+    },
+    sessionObservable,
+  }
 }
 
-/**
- * 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)
+// Thrown when the browsing context tears down mid-lock-request.
+//   - "AbortError: Promise was rejected because the browsing context is going away" (Webkit)
+//   - "Error: Failed to execute 'request' on 'LockManager': The provided callback is no longer runnable." (Chromium)
+function isContextGoingAwayError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false
   }
-
-  const sessionString = getCookie(SESSION_STORE_KEY)
-  const sessionState = toSessionState(sessionString)
-  return sessionState
+  return error.name === 'AbortError' || error.message.includes('no longer runnable')
 }
 
-export function buildCookieOptions(initConfiguration: InitConfiguration): CookieOptions | undefined {
-  const cookieOptions: CookieOptions = {}
+export function createCookieAccess(cookieApi: CookieApi, cookieOptions: CookieOptions): CookieAccess {
+  return cookieApi === CookieApi.COOKIE_STORE
+    ? createCookieStoreAccess(SESSION_STORE_KEY, cookieOptions)
+    : createDocumentCookieAccess(SESSION_STORE_KEY, cookieOptions)
+}
 
-  cookieOptions.secure =
-    !!initConfiguration.useSecureSessionCookie || !!initConfiguration.usePartitionedCrossSiteSessionCookie
-  cookieOptions.crossSite = !!initConfiguration.usePartitionedCrossSiteSessionCookie
-  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie
+function findMatchingSessionState(items: string[], opts: string): SessionState {
+  let sessionState: SessionState | undefined
 
-  if (initConfiguration.trackSessionAcrossSubdomains) {
-    const currentSite = getCurrentSite()
-    if (!currentSite) {
-      return
+  // reverse the cookies so that if there is no match, the cookie returned is the first one
+  for (const item of items.slice().reverse()) {
+    sessionState = toSessionState(item)
+    if (sessionState.c === opts) {
+      break
     }
-    cookieOptions.domain = currentSite
   }
 
-  return cookieOptions
+  // remove the cookie options from the session state as this is not part of the session state
+  delete sessionState?.c
+
+  return sessionState ?? {}
+}
+
+function buildSessionString(sessionState: SessionState, cookieOptions: CookieOptions): string {
+  return toSessionString(
+    isEmptyObject(sessionState) ? sessionState : { ...sessionState, c: encodeCookieOptions(cookieOptions) }
+  )
 }
 
 function encodeCookieOptions(cookieOptions: CookieOptions): string {
@@ -118,29 +159,3 @@ function encodeCookieOptions(cookieOptions: CookieOptions): string {
 
   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,10 +1,11 @@
 import { generateUUID } from '../../../tools/utils/stringUtils'
-import type { Configuration } from '../../configuration'
+import { Observable } from '../../../tools/observable'
+import { addEventListener } from '../../../browser/addEventListener'
 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'
+import { isSessionInNotStartedState, toSessionString, toSessionState } from '../sessionState'
+import type { SessionStateOperation, SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+import { SESSION_STORE_KEY, LEGACY_SESSION_STORE_KEY } from './sessionStoreStrategy'
 
 const LOCAL_STORAGE_TEST_KEY = '_kubesense_test_'
 
@@ -21,24 +22,35 @@ export function selectLocalStorageStrategy(): SessionStoreStrategyType | undefin
   }
 }
 
-export function initLocalStorageStrategy(configuration: Configuration): SessionStoreStrategy {
-  return {
-    isLockEnabled: false,
-    persistSession: persistInLocalStorage,
-    retrieveSession: retrieveSessionFromLocalStorage,
-    expireSession: (sessionState: SessionState) => expireSessionFromLocalStorage(sessionState, configuration),
-  }
-}
+export function initLocalStorageStrategy(): SessionStoreStrategy {
+  const sessionObservable = new Observable<SessionState>(
+    (observable) =>
+      addEventListener(window, 'storage', (event) => {
+        if (event.key === SESSION_STORE_KEY && event.storageArea === localStorage) {
+          observable.notify(toSessionState(event.newValue))
+        }
+      }).stop
+  )
 
-function persistInLocalStorage(sessionState: SessionState) {
-  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
-}
+  let isFirstCall = true
 
-export function retrieveSessionFromLocalStorage(): SessionState {
-  const sessionString = localStorage.getItem(SESSION_STORE_KEY)
-  return toSessionState(sessionString)
-}
+  return {
+    async setSessionState(
+      fn: (sessionState: SessionState) => SessionState,
+      _operation: SessionStateOperation
+    ): Promise<void> {
+      let currentState = toSessionState(localStorage.getItem(SESSION_STORE_KEY))
 
-function expireSessionFromLocalStorage(previousSessionState: SessionState, configuration: Configuration) {
-  persistInLocalStorage(getExpiredSessionState(previousSessionState, configuration))
+      if (isFirstCall && isSessionInNotStartedState(currentState)) {
+        currentState = toSessionState(localStorage.getItem(LEGACY_SESSION_STORE_KEY))
+      }
+      isFirstCall = false
+
+      const newState = fn(currentState)
+      localStorage.setItem(SESSION_STORE_KEY, toSessionString(newState))
+      await Promise.resolve()
+      sessionObservable.notify(newState)
+    },
+    sessionObservable,
+  }
 }

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

@@ -0,0 +1,55 @@
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { Observable } from '../../../tools/observable'
+import { shallowClone } from '../../../tools/utils/objectUtils'
+import { SessionPersistence } from '../sessionConstants'
+import type { SessionState } from '../sessionState'
+import type { SessionStateOperation, SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
+
+export const MEMORY_SESSION_STORE_KEY = '_KUBESENSE_SESSION'
+
+export interface MemorySession {
+  state?: SessionState
+  onChange?: (state: SessionState) => void
+}
+
+export interface GlobalObjectWithSession {
+  [MEMORY_SESSION_STORE_KEY]?: MemorySession
+}
+
+export function selectMemorySessionStoreStrategy(): SessionStoreStrategyType {
+  return { type: SessionPersistence.MEMORY }
+}
+
+export function initMemorySessionStoreStrategy(): SessionStoreStrategy {
+  const globalObjectWithSession = globalObject as GlobalObjectWithSession
+
+  // Share the observable across SDK instances (RUM + Logs)
+  if (!globalObjectWithSession[MEMORY_SESSION_STORE_KEY]) {
+    globalObjectWithSession[MEMORY_SESSION_STORE_KEY] = {}
+  }
+  const memorySession = globalObjectWithSession[MEMORY_SESSION_STORE_KEY]
+
+  const sessionObservable = new Observable<SessionState>()
+
+  // Wire the local observable to the shared onChange callback so that
+  // multiple SDK instances (RUM + Logs) can observe each other's changes.
+  const previousOnChange = memorySession.onChange
+  memorySession.onChange = (state: SessionState) => {
+    previousOnChange?.(state)
+    sessionObservable.notify(state)
+  }
+
+  return {
+    async setSessionState(
+      fn: (sessionState: SessionState) => SessionState,
+      _operation: SessionStateOperation
+    ): Promise<void> {
+      const currentState = memorySession.state ?? {}
+      const newState = shallowClone(fn(currentState))
+      memorySession.state = newState
+      await Promise.resolve()
+      memorySession.onChange?.(newState)
+    },
+    sessionObservable,
+  }
+}

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

@@ -1,16 +1,38 @@
 import type { CookieOptions } from '../../../browser/cookie'
 import type { SessionPersistence } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
+import type { Observable } from '../../../tools/observable'
 
-export const SESSION_STORE_KEY = '_kubesense_s'
+export const SESSION_STORE_KEY = '_kubesense_s_v2'
+export const LEGACY_SESSION_STORE_KEY = '_kubesense_s'
+
+export const enum CookieApi {
+  DOCUMENT_COOKIE,
+  COOKIE_STORE,
+}
+
+export interface CookieSessionStoreStrategyType {
+  type: typeof SessionPersistence.COOKIE
+  cookieOptions: CookieOptions
+  cookieApi: CookieApi
+}
 
 export type SessionStoreStrategyType =
-  | { type: typeof SessionPersistence.COOKIE; cookieOptions: CookieOptions }
+  | CookieSessionStoreStrategyType
   | { type: typeof SessionPersistence.LOCAL_STORAGE }
+  | { type: typeof SessionPersistence.MEMORY }
+
+export type SessionStateOperation =
+  | 'initialize'
+  | 'expandOrRenewOnActivity'
+  | 'expandOrRenewOnConsent'
+  | 'expandOnVisibility'
+  | 'initializeOnResume'
+  | 'expireOnTimeout'
+  | 'expire'
+  | 'updateState'
 
 export interface SessionStoreStrategy {
-  isLockEnabled: boolean
-  persistSession: (session: SessionState) => void
-  retrieveSession: () => SessionState
-  expireSession: (previousSessionState: SessionState) => void
+  setSessionState(fn: (sessionState: SessionState) => SessionState, operation: SessionStateOperation): Promise<void>
+  sessionObservable: Observable<SessionState>
 }

package/src/domain/sourceCodeContext.ts

@@ -0,0 +1,100 @@
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import { computeStackTrace } from '../tools/stackTrace/computeStackTrace'
+import { addTelemetryUsage } from './telemetry'
+
+/**
+ * Entry of the `KUBESENSE_SOURCE_CODE_CONTEXT` map injected at build time. Depending on the build plugin
+ * configuration, an entry can hold:
+ * - service/version only (source code attribution),
+ * - a debug ID only (sourcemap resolution),
+ * - or both.
+ */
+export interface SourceCodeContextEntry {
+  service?: string
+  version?: string
+  ddDebugId?: string
+}
+
+export interface BrowserWindow {
+  KUBESENSE_SOURCE_CODE_CONTEXT?: Record<string, SourceCodeContextEntry>
+}
+
+const contextByUrl = new Map<string, SourceCodeContextEntry>()
+const processedStacks = new Set<string>()
+let hasFiredTelemetry = false
+
+function syncSourceCodeContext() {
+  // globalObject.window is undefined in service worker environments
+  const sourceCodeContext = (globalObject.window as BrowserWindow | undefined)?.KUBESENSE_SOURCE_CODE_CONTEXT
+  if (!sourceCodeContext) {
+    return
+  }
+
+  let useDebugId = false
+  let useService = false
+  let useVersion = false
+
+  for (const [stack, entry] of Object.entries(sourceCodeContext)) {
+    useDebugId = useDebugId || entry.ddDebugId !== undefined
+    useService = useService || entry.service !== undefined
+    useVersion = useVersion || entry.version !== undefined
+
+    if (processedStacks.has(stack)) {
+      continue
+    }
+
+    processedStacks.add(stack)
+
+    const url = computeStackTrace({ stack }).stack[0]?.url
+    if (url && !contextByUrl.has(url)) {
+      contextByUrl.set(url, entry)
+    }
+  }
+
+  if (!hasFiredTelemetry) {
+    hasFiredTelemetry = true
+    addTelemetryUsage({
+      feature: 'source-code-context',
+      use_debug_id: useDebugId,
+      use_service: useService,
+      use_version: useVersion,
+    })
+  }
+}
+
+export interface DebugIdEntry {
+  url: string
+  id: string
+}
+
+export function buildDebugIdByUrl(urls: string[]): DebugIdEntry[] | undefined {
+  syncSourceCodeContext()
+
+  const seenUrls = new Set<string>()
+  const debugIds: DebugIdEntry[] = []
+
+  for (const url of urls) {
+    if (seenUrls.has(url)) {
+      continue
+    }
+    seenUrls.add(url)
+
+    const debugId = contextByUrl.get(url)?.ddDebugId
+    if (debugId !== undefined) {
+      debugIds.push({ url, id: debugId })
+    }
+  }
+
+  return debugIds.length ? debugIds : undefined
+}
+
+export function getSourceCodeContext(url: string): SourceCodeContextEntry | undefined {
+  syncSourceCodeContext()
+  return contextByUrl.get(url)
+}
+
+export function resetSourceCodeContext() {
+  contextByUrl.clear()
+  processedStacks.clear()
+  hasFiredTelemetry = false
+}

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -1,14 +1,24 @@
+import { globalObject, isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
 import { getInitCookie } from '../../browser/cookie'
-import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
+import { tryJsonParse } from '../../tools/utils/objectUtils'
 
-export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'kubesense-synthetics-public-id'
-export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'kubesense-synthetics-result-id'
-export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'kubesense-synthetics-injects-rum'
+const cookieNamePrefix = 'kubesense-synthetics-'
+export const SYNTHETICS_TEST_ID_COOKIE_NAME = `${cookieNamePrefix}public-id`
+export const SYNTHETICS_RESULT_ID_COOKIE_NAME = `${cookieNamePrefix}result-id`
+export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = `${cookieNamePrefix}injects-rum`
+export const SYNTHETICS_CONTEXT_COOKIE_NAME = `${cookieNamePrefix}rum-context`
 
-export interface BrowserWindow extends Window {
+export interface BrowserWindow {
   _KUBESENSE_SYNTHETICS_PUBLIC_ID?: unknown
   _KUBESENSE_SYNTHETICS_RESULT_ID?: unknown
   _KUBESENSE_SYNTHETICS_INJECTS_RUM?: unknown
+  _KUBESENSE_SYNTHETICS_RUM_CONTEXT?: unknown
+}
+
+export interface SyntheticsContext {
+  test_id: string
+  result_id: string
+  [key: string]: unknown
 }
 
 export function willSyntheticsInjectRum(): boolean {
@@ -18,21 +28,43 @@ export function willSyntheticsInjectRum(): boolean {
   }
 
   return Boolean(
-    (globalObject as BrowserWindow)._KUBESENSE_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+    (globalObject as BrowserWindow)._KUBESENSE_SYNTHETICS_INJECTS_RUM ||
+    getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
   )
 }
 
-export function getSyntheticsTestId(): string | undefined {
-  const value = (window as BrowserWindow)._KUBESENSE_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
-  return typeof value === 'string' ? value : undefined
+export function getSyntheticsContext(): SyntheticsContext | undefined {
+  const raw = getRawSyntheticsContext()
+  return isValidSyntheticsContext(raw) ? raw : undefined
 }
 
-export function getSyntheticsResultId(): string | undefined {
-  const value =
-    (window as BrowserWindow)._KUBESENSE_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
-  return typeof value === 'string' ? value : undefined
+export function isSyntheticsTest(): boolean {
+  return Boolean(getSyntheticsContext())
 }
 
-export function isSyntheticsTest(): boolean {
-  return Boolean(getSyntheticsTestId() && getSyntheticsResultId())
+function getRawSyntheticsContext(): unknown {
+  const rawGlobal = (globalObject as BrowserWindow)._KUBESENSE_SYNTHETICS_RUM_CONTEXT
+  if (rawGlobal) {
+    return rawGlobal
+  }
+
+  const rawCookie = getInitCookie(SYNTHETICS_CONTEXT_COOKIE_NAME)
+  if (rawCookie) {
+    return tryJsonParse(decodeURIComponent(rawCookie))
+  }
+
+  return {
+    test_id: (window as BrowserWindow)._KUBESENSE_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME),
+    result_id:
+      (window as BrowserWindow)._KUBESENSE_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME),
+  }
+}
+
+function isValidSyntheticsContext(value: unknown): value is SyntheticsContext {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as Record<string, unknown>).test_id === 'string' &&
+    typeof (value as Record<string, unknown>).result_id === 'string'
+  )
 }

package/src/domain/tags.ts

@@ -1,5 +1,6 @@
-import { DOCS_ORIGIN, MORE_DETAILS, display } from '../tools/display'
-import type { Configuration } from './configuration/configuration'
+import { DOCS_ORIGIN, MORE_DETAILS } from '@kubesense/kubesense-js-core/util'
+import { display } from '../tools/display'
+import type { Configuration } from './configuration'
 
 export const TAG_SIZE_LIMIT = 200
 
@@ -31,7 +32,8 @@ export function buildTags(configuration: Configuration): string[] {
 }
 
 export function buildTag(key: string, rawValue?: string) {
-  // Note that the backend may not follow the exact same rules, so we only want to display an informal
+  // See https://docs.kubesense.ai/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
 
@@ -51,25 +53,9 @@ export function sanitizeTag(tag: string) {
 }
 
 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
-  }
-}