@openobserve/browser-core 0.2.10 → 0.2.11-rc1

package/src/domain/context/customerDataTracker.ts

@@ -0,0 +1,134 @@
+import { ONE_KIBI_BYTE, computeBytesCount } from '../../tools/utils/byteUtils'
+import { throttle } from '../../tools/utils/functionUtils'
+import type { Context } from '../../tools/serialisation/context'
+import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import { display } from '../../tools/display'
+import { isEmptyObject } from '../../tools/utils/objectUtils'
+import type { CustomerDataType } from './contextConstants'
+
+// RUM and logs batch bytes limit is 16KB
+// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
+// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
+export const CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE
+
+// We observed that the compression ratio is around 8 in general, but we also want to keep a margin
+// because some data might not be compressed (ex: last view update on page exit). We chose 16KiB
+// because it is also the limit of the 'batchBytesCount' that we use for RUM and Logs data, but this
+// is a bit arbitrary.
+export const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE
+
+export const BYTES_COMPUTATION_THROTTLING_DELAY = 200
+
+export type CustomerDataTracker = ReturnType<typeof createCustomerDataTracker>
+export type CustomerDataTrackerManager = ReturnType<typeof createCustomerDataTrackerManager>
+
+export const enum CustomerDataCompressionStatus {
+  Unknown,
+  Enabled,
+  Disabled,
+}
+
+export function createCustomerDataTrackerManager(
+  compressionStatus: CustomerDataCompressionStatus = CustomerDataCompressionStatus.Disabled
+) {
+  const customerDataTrackers = new Map<CustomerDataType, CustomerDataTracker>()
+
+  let alreadyWarned = false
+  function checkCustomerDataLimit(initialBytesCount = 0) {
+    if (alreadyWarned || compressionStatus === CustomerDataCompressionStatus.Unknown) {
+      return
+    }
+
+    const bytesCountLimit =
+      compressionStatus === CustomerDataCompressionStatus.Disabled
+        ? CUSTOMER_DATA_BYTES_LIMIT
+        : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT
+
+    let bytesCount = initialBytesCount
+    customerDataTrackers.forEach((tracker) => {
+      bytesCount += tracker.getBytesCount()
+    })
+
+    if (bytesCount > bytesCountLimit) {
+      displayCustomerDataLimitReachedWarning(bytesCountLimit)
+      alreadyWarned = true
+    }
+  }
+
+  return {
+    /**
+     * Creates a detached tracker. The manager will not store a reference to that tracker, and the
+     * bytes count will be counted independently from other detached trackers.
+     *
+     * This is particularly useful when we don't know when the tracker will be unused, so we don't
+     * leak memory (ex: when used in Logger instances).
+     */
+    createDetachedTracker: () => {
+      const tracker = createCustomerDataTracker(() => checkCustomerDataLimit(tracker.getBytesCount()))
+      return tracker
+    },
+
+    /**
+     * Creates a tracker if it doesn't exist, and returns it.
+     */
+    getOrCreateTracker: (type: CustomerDataType) => {
+      if (!customerDataTrackers.has(type)) {
+        customerDataTrackers.set(type, createCustomerDataTracker(checkCustomerDataLimit))
+      }
+      return customerDataTrackers.get(type)!
+    },
+
+    setCompressionStatus: (newCompressionStatus: CustomerDataCompressionStatus) => {
+      if (compressionStatus === CustomerDataCompressionStatus.Unknown) {
+        compressionStatus = newCompressionStatus
+        checkCustomerDataLimit()
+      }
+    },
+
+    getCompressionStatus: () => compressionStatus,
+
+    stop: () => {
+      customerDataTrackers.forEach((tracker) => tracker.stop())
+      customerDataTrackers.clear()
+    },
+  }
+}
+
+export function createCustomerDataTracker(checkCustomerDataLimit: () => void) {
+  let bytesCountCache = 0
+
+  // Throttle the bytes computation to minimize the impact on performance.
+  // Especially useful if the user call context APIs synchronously multiple times in a row
+  const { throttled: computeBytesCountThrottled, cancel: cancelComputeBytesCount } = throttle((context: Context) => {
+    bytesCountCache = computeBytesCount(jsonStringify(context)!)
+    checkCustomerDataLimit()
+  }, BYTES_COMPUTATION_THROTTLING_DELAY)
+
+  const resetBytesCount = () => {
+    cancelComputeBytesCount()
+    bytesCountCache = 0
+  }
+
+  return {
+    updateCustomerData: (context: Context) => {
+      if (isEmptyObject(context)) {
+        resetBytesCount()
+      } else {
+        computeBytesCountThrottled(context)
+      }
+    },
+    resetCustomerData: resetBytesCount,
+    getBytesCount: () => bytesCountCache,
+    stop: () => {
+      cancelComputeBytesCount()
+    },
+  }
+}
+
+function displayCustomerDataLimitReachedWarning(bytesCountLimit: number) {
+  display.warn(
+    `Customer data exceeds the recommended ${
+      bytesCountLimit / ONE_KIBI_BYTE
+    }KiB threshold. More details: https://docs.datadoghq.com/real_user_monitoring/browser/troubleshooting/#customer-data-exceeds-the-recommended-threshold-warning`
+  )
+}

package/src/domain/context/storeContextManager.ts

@@ -0,0 +1,51 @@
+import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
+import type { Context } from '../../tools/serialisation/context'
+import type { Configuration } from '../configuration'
+import { combine } from '../../tools/mergeInto'
+import type { ContextManager } from './contextManager'
+import type { CustomerDataType } from './contextConstants'
+
+const CONTEXT_STORE_KEY_PREFIX = '_oo_c'
+
+const storageListeners: Array<{ stop: () => void }> = []
+
+export function storeContextManager(
+  configuration: Configuration,
+  contextManager: ContextManager,
+  productKey: string,
+  customerDataType: CustomerDataType
+) {
+  const storageKey = buildStorageKey(productKey, customerDataType)
+
+  storageListeners.push(
+    addEventListener(configuration, window, DOM_EVENT.STORAGE, ({ key }) => {
+      if (storageKey === key) {
+        synchronizeWithStorage()
+      }
+    })
+  )
+  contextManager.changeObservable.subscribe(dumpToStorage)
+
+  contextManager.setContext(combine(getFromStorage(), contextManager.getContext()))
+
+  function synchronizeWithStorage() {
+    contextManager.setContext(getFromStorage())
+  }
+
+  function dumpToStorage() {
+    localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()))
+  }
+
+  function getFromStorage() {
+    const rawContext = localStorage.getItem(storageKey)
+    return rawContext !== null ? (JSON.parse(rawContext) as Context) : {}
+  }
+}
+
+export function buildStorageKey(productKey: string, customerDataType: CustomerDataType) {
+  return `${CONTEXT_STORE_KEY_PREFIX}_${productKey}_${customerDataType}`
+}
+
+export function removeStorageListeners() {
+  storageListeners.map((listener) => listener.stop())
+}

package/src/domain/deflate/types.ts

@@ -1,3 +1,5 @@
+import type { Encoder } from '../../tools/encoder'
+
 export type DeflateWorkerAction =
   // Action to send when creating the worker to check if the communication is working correctly.
   // The worker should respond with a 'initialized' response.
@@ -39,3 +41,15 @@ export type DeflateWorkerResponse =
       streamId?: number
       error: Error | string
     }
+
+export interface DeflateWorker extends Worker {
+  postMessage(message: DeflateWorkerAction): void
+}
+
+export type DeflateEncoder = Encoder<Uint8Array> & { stop: () => void }
+
+export const enum DeflateEncoderStreamId {
+  REPLAY = 1,
+  RUM = 2,
+  RUM_REPLICA = 3,
+}

package/src/domain/{tracekit → error}/computeStackTrace.ts

@@ -1,11 +1,33 @@
+/**
+ * Cross-browser stack trace computation.
+ *
+ * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js
+ */
+
 import { startsWith } from '../../tools/utils/polyfills'
-import type { StackTrace, StackFrame } from './types'
+
+export interface StackFrame {
+  url?: string
+  func?: string
+  /** The arguments passed to the function, if known. */
+  args?: string[]
+  line?: number
+  column?: number
+  /** An array of source code lines; the middle element corresponds to the correct line. */
+  context?: string[]
+}
+
+export interface StackTrace {
+  name?: string
+  message?: string
+  url?: string
+  stack: StackFrame[]
+  incomplete?: boolean
+  partial?: boolean
+}
 
 const UNKNOWN_FUNCTION = '?'
 
-/**
- * Computes a stack trace for an exception.
- */
 export function computeStackTrace(ex: unknown): StackTrace {
   const stack: StackFrame[] = []
 
@@ -139,3 +161,26 @@ function tryToGetString(candidate: unknown, property: string) {
   const value = (candidate as { [k: string]: unknown })[property]
   return typeof value === 'string' ? value : undefined
 }
+
+export function computeStackTraceFromOnErrorMessage(messageObj: unknown, url?: string, line?: number, column?: number) {
+  const stack = [{ url, column, line }]
+  const { name, message } = tryToParseMessage(messageObj)
+  return {
+    name,
+    message,
+    stack,
+  }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
+const ERROR_TYPES_RE =
+  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\s\S]*)$/
+
+function tryToParseMessage(messageObj: unknown) {
+  let name
+  let message
+  if ({}.toString.call(messageObj) === '[object String]') {
+    ;[, name, message] = ERROR_TYPES_RE.exec(messageObj as string)!
+  }
+  return { name, message }
+}

package/src/domain/error/error.ts

@@ -1,11 +1,11 @@
-import type { StackTrace } from '../tracekit'
-import { computeStackTrace } from '../tracekit'
 import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import type { ClocksState } from '../../tools/utils/timeUtils'
 import { noop } from '../../tools/utils/functionUtils'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
 import type { ErrorSource, ErrorHandling, RawError, RawErrorCause, ErrorWithCause, NonErrorPrefix } from './error.types'
+import type { StackTrace } from './computeStackTrace'
+import { computeStackTrace } from './computeStackTrace'
 
 export const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'
 

package/src/domain/error/error.types.ts

@@ -1,7 +1,16 @@
 import type { ClocksState } from '../../tools/utils/timeUtils'
 
-export interface ErrorWithCause extends Error {
-  cause?: Error
+// TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be
+// `unknown`[2].
+//
+// Because we still support TS 3.8, we need to declare our own type. We can remove it once we drop
+// support for TS v4.7 and before. The 'cause' property defined by TS needs to be omitted because
+// we define it with a type `unknown` which is incompatible with TS 4.6 and 4.7.
+//
+// [1]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-6/#target-es2022
+// [2]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-8/#lib-d-ts-updates
+export interface ErrorWithCause extends Omit<Error, 'cause'> {
+  cause?: unknown
 }
 
 export type RawErrorCause = {

package/src/domain/error/trackRuntimeError.ts

@@ -1,21 +1,53 @@
+import { instrumentMethod } from '../../tools/instrumentMethod'
 import type { Observable } from '../../tools/observable'
 import { clocksNow } from '../../tools/utils/timeUtils'
-import { startUnhandledErrorCollection } from '../tracekit'
+import type { StackTrace } from './computeStackTrace'
+import { computeStackTrace, computeStackTraceFromOnErrorMessage } from './computeStackTrace'
 import { computeRawError } from './error'
 import type { RawError } from './error.types'
 import { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'
 
+export type UnhandledErrorCallback = (stackTrace: StackTrace, originalError?: any) => any
+
 export function trackRuntimeError(errorObservable: Observable<RawError>) {
-  return startUnhandledErrorCollection((stackTrace, originalError) => {
-    errorObservable.notify(
-      computeRawError({
-        stackTrace,
-        originalError,
-        startClocks: clocksNow(),
-        nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
-        source: ErrorSource.SOURCE,
-        handling: ErrorHandling.UNHANDLED,
-      })
-    )
+  const handleRuntimeError = (stackTrace: StackTrace, originalError?: any) => {
+    const test = computeRawError({
+      stackTrace,
+      originalError,
+      startClocks: clocksNow(),
+      nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
+      source: ErrorSource.SOURCE,
+      handling: ErrorHandling.UNHANDLED,
+    })
+    errorObservable.notify(test)
+  }
+  const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)
+  const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)
+
+  return {
+    stop: () => {
+      stopInstrumentingOnError()
+      stopInstrumentingOnUnhandledRejection()
+    },
+  }
+}
+
+export function instrumentOnError(callback: UnhandledErrorCallback) {
+  return instrumentMethod(window, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+    let stackTrace
+    if (errorObj instanceof Error) {
+      stackTrace = computeStackTrace(errorObj)
+    } else {
+      stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)
+    }
+    callback(stackTrace, errorObj ?? messageObj)
+  })
+}
+
+export function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
+  return instrumentMethod(window, 'onunhandledrejection', ({ parameters: [e] }) => {
+    const reason = e.reason || 'Empty reason'
+    const stack = computeStackTrace(reason)
+    callback(stack, reason)
   })
 }

package/src/domain/report/browser.types.ts

@@ -1,5 +1,16 @@
 export type ReportType = DeprecationReport['type'] | InterventionReport['type']
 
+interface Report {
+  type: ReportType
+  url: string
+  body: DeprecationReportBody | InterventionReportBody
+  toJSON(): any
+}
+
+interface ReportBody {
+  toJSON(): any
+}
+
 export interface DeprecationReport extends Report {
   type: 'deprecation'
   body: DeprecationReportBody
@@ -17,6 +28,7 @@ export interface InterventionReport extends Report {
   type: 'intervention'
   body: InterventionReportBody
 }
+
 export interface InterventionReportBody extends ReportBody {
   id: string
   message: string

package/src/domain/report/reportObservable.ts

@@ -19,6 +19,7 @@ export interface RawReport {
   type: RawReportType
   subtype: string
   message: string
+  originalReport: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport
   stack?: string
 }
 
@@ -38,7 +39,7 @@ export function initReportObservable(configuration: Configuration, apis: RawRepo
 }
 
 function createReportObservable(reportTypes: ReportType[]) {
-  const observable = new Observable<RawReport>(() => {
+  return new Observable<RawReport>((observable) => {
     if (!window.ReportingObserver) {
       return
     }
@@ -59,26 +60,26 @@ function createReportObservable(reportTypes: ReportType[]) {
       observer.disconnect()
     }
   })
-
-  return observable
 }
 
 function createCspViolationReportObservable(configuration: Configuration) {
-  const observable = new Observable<RawReport>(() => {
+  return new Observable<RawReport>((observable) => {
     const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
       observable.notify(buildRawReportFromCspViolation(event))
     })
 
     return stop
   })
-  return observable
 }
 
-function buildRawReportFromReport({ type, body }: DeprecationReport | InterventionReport): RawReport {
+function buildRawReportFromReport(report: DeprecationReport | InterventionReport): RawReport {
+  const { type, body } = report
+
   return {
     type,
     subtype: body.id,
     message: `${type}: ${body.message}`,
+    originalReport: report,
     stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
   }
 }
@@ -99,6 +100,7 @@ function buildRawReportFromCspViolation(event: SecurityPolicyViolationEvent): Ra
       event.lineNumber,
       event.columnNumber
     ),
+    originalReport: event,
   }
 }
 

package/src/domain/session/oldCookiesMigration.ts

@@ -1,4 +1,4 @@
-import { getCookie } from '../../browser/cookie'
+import { getInitCookie } from '../../browser/cookie'
 import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
 import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
 import type { SessionState } from './sessionState'
@@ -17,11 +17,11 @@ export const LOGS_SESSION_KEY = 'logs'
  * to allow older sdk versions to be upgraded to newer versions without compatibility issues.
  */
 export function tryOldCookiesMigration(cookieStoreStrategy: SessionStoreStrategy) {
-  const sessionString = getCookie(SESSION_STORE_KEY)
+  const sessionString = getInitCookie(SESSION_STORE_KEY)
   if (!sessionString) {
-    const oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME)
-    const oldRumType = getCookie(OLD_RUM_COOKIE_NAME)
-    const oldLogsType = getCookie(OLD_LOGS_COOKIE_NAME)
+    const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME)
+    const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME)
+    const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME)
     const session: SessionState = {}
 
     if (oldSessionId) {

package/src/domain/session/sessionStoreOperations.ts

@@ -1,6 +1,5 @@
 import { setTimeout } from '../../tools/timer'
 import { generateUUID } from '../../tools/utils/stringUtils'
-import { isChromium } from '../../tools/utils/browserDetection'
 import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
 import type { SessionState } from './sessionState'
 import { expandSessionState, isSessionInExpiredState } from './sessionState'
@@ -20,8 +19,7 @@ export function processSessionStoreOperations(
   sessionStoreStrategy: SessionStoreStrategy,
   numberOfRetries = 0
 ) {
-  const { retrieveSession, persistSession, clearSession } = sessionStoreStrategy
-  const lockEnabled = isLockEnabled()
+  const { isLockEnabled, retrieveSession, persistSession, clearSession } = sessionStoreStrategy
 
   if (!ongoingOperations) {
     ongoingOperations = operations
@@ -30,13 +28,13 @@ export function processSessionStoreOperations(
     bufferedOperations.push(operations)
     return
   }
-  if (lockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
     next(sessionStoreStrategy)
     return
   }
   let currentLock: string
   let currentSession = retrieveSession()
-  if (lockEnabled) {
+  if (isLockEnabled) {
     // if someone has lock, retry later
     if (currentSession.lock) {
       retryLater(operations, sessionStoreStrategy, numberOfRetries)
@@ -54,7 +52,7 @@ export function processSessionStoreOperations(
     }
   }
   let processedSession = operations.process(currentSession)
-  if (lockEnabled) {
+  if (isLockEnabled) {
     // if lock corrupted after process, retry later
     currentSession = retrieveSession()
     if (currentSession.lock !== currentLock!) {
@@ -70,7 +68,7 @@ export function processSessionStoreOperations(
       persistSession(processedSession)
     }
   }
-  if (lockEnabled) {
+  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))) {
@@ -91,12 +89,6 @@ export function processSessionStoreOperations(
   next(sessionStoreStrategy)
 }
 
-/**
- * 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.
- */
-export const isLockEnabled = () => isChromium()
-
 function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
   setTimeout(() => {
     processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)

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

@@ -1,3 +1,4 @@
+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'
@@ -15,6 +16,11 @@ export function selectCookieStrategy(initConfiguration: InitConfiguration): Sess
 
 export function initCookieStrategy(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: persistSessionCookie(cookieOptions),
     retrieveSession: retrieveSessionCookie,
     clearSession: deleteSessionCookie(cookieOptions),
@@ -45,8 +51,13 @@ function deleteSessionCookie(options: CookieOptions) {
 export function buildCookieOptions(initConfiguration: InitConfiguration) {
   const cookieOptions: CookieOptions = {}
 
-  cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
-  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.secure =
+    !!initConfiguration.useSecureSessionCookie ||
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie ||
+    !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.crossSite =
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie
 
   if (initConfiguration.trackSessionAcrossSubdomains) {
     cookieOptions.domain = getCurrentSite()

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

@@ -21,6 +21,7 @@ export function selectLocalStorageStrategy(): SessionStoreStrategyType | undefin
 
 export function initLocalStorageStrategy(): SessionStoreStrategy {
   return {
+    isLockEnabled: false,
     persistSession: persistInLocalStorage,
     retrieveSession: retrieveSessionFromLocalStorage,
     clearSession: clearSessionFromLocalStorage,

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

@@ -6,6 +6,7 @@ export const SESSION_STORE_KEY = '_oo_s'
 export type SessionStoreStrategyType = { type: 'Cookie'; cookieOptions: CookieOptions } | { type: 'LocalStorage' }
 
 export interface SessionStoreStrategy {
+  isLockEnabled: boolean
   persistSession: (session: SessionState) => void
   retrieveSession: () => SessionState
   clearSession: () => void

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -1,4 +1,4 @@
-import { getCookie } from '../../browser/cookie'
+import { getInitCookie } from '../../browser/cookie'
 
 export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'openobserve-synthetics-public-id'
 export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'openobserve-synthetics-result-id'
@@ -12,16 +12,16 @@ export interface BrowserWindow extends Window {
 
 export function willSyntheticsInjectRum(): boolean {
   return Boolean(
-    (window as BrowserWindow)._OO_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+    (window 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
 }

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

@@ -10,5 +10,10 @@ 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']