@openobserve/browser-core 0.2.11-rc1 → 0.2.11

package/src/domain/configuration/configuration.ts

@@ -24,15 +24,22 @@ export interface InitConfiguration {
   // global options
   clientToken: string
   beforeSend?: GenericBeforeSendCallback | undefined
+  /**
+   * @deprecated use sessionSampleRate instead
+   */
+  sampleRate?: number | undefined
   sessionSampleRate?: number | undefined
   telemetrySampleRate?: number | undefined
   silentMultipleInit?: boolean | undefined
-  allowFallbackToLocalStorage?: boolean | undefined
-  allowUntrustedEvents?: boolean | undefined
-  storeContextsAcrossPages?: boolean | undefined
+  trackResources?: boolean | undefined
+  trackLongTasks?: boolean | undefined
 
   // transport options
-  proxy?: string | ProxyFn | undefined
+  proxy?: string | undefined
+  /**
+   * @deprecated use `proxy` instead
+   */
+  proxyUrl?: string | undefined
   site?: string | undefined
 
   // tag and context options
@@ -41,19 +48,17 @@ export interface InitConfiguration {
   version: string | undefined
 
   // cookie options
-  /**
-   * @deprecated use usePartitionedCrossSiteSessionCookie instead
-   */
   useCrossSiteSessionCookie?: boolean | undefined
-  usePartitionedCrossSiteSessionCookie?: boolean | undefined
   useSecureSessionCookie?: boolean | undefined
   trackSessionAcrossSubdomains?: boolean | undefined
 
+  // alternate storage option
+  allowFallbackToLocalStorage?: boolean | undefined
+
   // internal options
   enableExperimentalFeatures?: string[] | undefined
   replica?: ReplicaUserConfiguration | undefined
   datacenter?: string
-  // TODO next major: remove this option and replace usages by proxyFn
   internalAnalyticsSubdomain?: string
 
   telemetryConfigurationSampleRate?: number
@@ -67,12 +72,6 @@ export interface InitConfiguration {
 // for this option.
 type GenericBeforeSendCallback = (event: any, context?: any) => unknown
 
-/**
- * path: /api/vX/product
- * parameters: xxx=yyy&zzz=aaa
- */
-type ProxyFn = (options: { path: string; parameters: string }) => string
-
 interface ReplicaUserConfiguration {
   applicationId?: string
   clientToken: string
@@ -87,7 +86,6 @@ export interface Configuration extends TransportConfiguration {
   telemetryConfigurationSampleRate: number
   service: string | undefined
   silentMultipleInit: boolean
-  allowUntrustedEvents: boolean
 
   // Event limits
   eventRateLimiterThreshold: number // Limit the maximum number of actions, errors and logs per minutes
@@ -106,7 +104,8 @@ export function validateAndBuildConfiguration(initConfiguration: InitConfigurati
     return
   }
 
-  if (initConfiguration.sessionSampleRate !== undefined && !isPercentage(initConfiguration.sessionSampleRate)) {
+  const sessionSampleRate = initConfiguration.sessionSampleRate ?? initConfiguration.sampleRate
+  if (sessionSampleRate !== undefined && !isPercentage(sessionSampleRate)) {
     display.error('Session Sample Rate should be a number between 0 and 100')
     return
   }
@@ -138,12 +137,11 @@ export function validateAndBuildConfiguration(initConfiguration: InitConfigurati
       beforeSend:
         initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),
       sessionStoreStrategyType: selectSessionStoreStrategyType(initConfiguration),
-      sessionSampleRate: initConfiguration.sessionSampleRate ?? 100,
+      sessionSampleRate: sessionSampleRate ?? 100,
       telemetrySampleRate: initConfiguration.telemetrySampleRate ?? 20,
       telemetryConfigurationSampleRate: initConfiguration.telemetryConfigurationSampleRate ?? 5,
       service: initConfiguration.service,
       silentMultipleInit: !!initConfiguration.silentMultipleInit,
-      allowUntrustedEvents: !!initConfiguration.allowUntrustedEvents,
 
       /**
        * beacon payload max queue size implementation is 64kb
@@ -175,19 +173,19 @@ export function validateAndBuildConfiguration(initConfiguration: InitConfigurati
 }
 
 export function serializeConfiguration(initConfiguration: InitConfiguration): Partial<RawTelemetryConfiguration> {
+  const proxy = initConfiguration.proxy ?? initConfiguration.proxyUrl
   return {
-    session_sample_rate: initConfiguration.sessionSampleRate,
+    session_sample_rate: initConfiguration.sessionSampleRate ?? initConfiguration.sampleRate,
     telemetry_sample_rate: initConfiguration.telemetrySampleRate,
     telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,
     use_before_send: !!initConfiguration.beforeSend,
     use_cross_site_session_cookie: initConfiguration.useCrossSiteSessionCookie,
-    use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,
     use_secure_session_cookie: initConfiguration.useSecureSessionCookie,
-    use_proxy: !!initConfiguration.proxy,
+    use_proxy: proxy !== undefined ? !!proxy : undefined,
     silent_multiple_init: initConfiguration.silentMultipleInit,
     track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,
+    track_resources: initConfiguration.trackResources,
+    track_long_task: initConfiguration.trackLongTasks,
     allow_fallback_to_local_storage: !!initConfiguration.allowFallbackToLocalStorage,
-    store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,
-    allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,
   }
 }

package/src/domain/configuration/endpointBuilder.ts

@@ -1,39 +1,51 @@
-import type { Payload } from '../../transport'
+import type { RetryInfo, FlushReason } from '../../transport'
 import { timeStampNow } from '../../tools/utils/timeUtils'
 import { normalizeUrl } from '../../tools/utils/urlPolyfill'
 import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
 import { generateUUID } from '../../tools/utils/stringUtils'
 import type { InitConfiguration } from './configuration'
-import { INTAKE_SITE_US1 } from './intakeSites'
+import { INTAKE_SITE_AP1, INTAKE_SITE_US1 } from './intakeSites'
 
 // replaced at build time
 declare const __BUILD_ENV__SDK_VERSION__: string
 
-export type TrackType = 'logs' | 'rum' | 'replay'
-export type ApiType =
-  | 'xhr'
-  | 'fetch'
-  | 'beacon'
-  // 'manual' reflects that the request have been sent manually, outside of the SDK (ex: via curl or
-  // a Node.js script).
-  | 'manual'
+export const ENDPOINTS = {
+  logs: 'logs',
+  rum: 'rum',
+  sessionReplay: 'session-replay',
+} as const
+
+const INTAKE_TRACKS = {
+  logs: 'logs',
+  rum: 'rum',
+  sessionReplay: 'replay',
+}
+
+export type EndpointType = keyof typeof ENDPOINTS
 
 export type EndpointBuilder = ReturnType<typeof createEndpointBuilder>
 
 export function createEndpointBuilder(
   initConfiguration: InitConfiguration,
-  trackType: TrackType,
+  endpointType: EndpointType,
   configurationTags: string[]
 ) {
-  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, trackType)
+  const buildUrlWithParameters = createEndpointUrlWithParametersBuilder(initConfiguration, endpointType)
 
   return {
-    build(api: ApiType, payload: Payload) {
-      const parameters = buildEndpointParameters(initConfiguration, trackType, configurationTags, api, payload)
+    build(api: 'xhr' | 'fetch' | 'beacon', flushReason?: FlushReason, retry?: RetryInfo) {
+      const parameters = buildEndpointParameters(
+        initConfiguration,
+        endpointType,
+        configurationTags,
+        api,
+        flushReason,
+        retry
+      )
       return buildUrlWithParameters(parameters)
     },
     urlPrefix: buildUrlWithParameters(''),
-    trackType,
+    endpointType,
   }
 }
 
@@ -44,26 +56,32 @@ export function createEndpointBuilder(
  */
 function createEndpointUrlWithParametersBuilder(
   initConfiguration: InitConfiguration,
-  trackType: TrackType
+  endpointType: EndpointType
 ): (parameters: string) => string {
-  const { proxy, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
+  const { proxy, proxyUrl, apiVersion, organizationIdentifier, insecureHTTP } = initConfiguration
 
-  const path = `/rum/${apiVersion}/${organizationIdentifier}/${trackType}`
+  const path = `/rum/${apiVersion}/${organizationIdentifier}/${INTAKE_TRACKS[endpointType]}`
 
   if (proxy) {
     const normalizedProxyUrl = normalizeUrl(proxy)
-    return (parameters) => `${normalizedProxyUrl}?o2forward=${encodeURIComponent(`${path}?${parameters}`)}`
+    return (parameters) => `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`${path}?${parameters}`)}`
   }
-  if (typeof proxy === 'function') {
-    return (parameters) => proxy({ path, parameters })
+
+  const host = buildEndpointHost(initConfiguration, endpointType)
+
+  if (proxy === undefined && proxyUrl) {
+    // TODO: remove this in a future major.
+    const normalizedProxyUrl = normalizeUrl(proxyUrl)
+    return (parameters) =>
+      `${normalizedProxyUrl}?ooforward=${encodeURIComponent(`https://${host}${path}?${parameters}`)}`
   }
-  const host = buildEndpointHost(initConfiguration)
+
   const protocol = insecureHTTP ? 'http' : 'https'
 
   return (parameters) => `${protocol}://${host}${path}?${parameters}`
 }
 
-function buildEndpointHost(initConfiguration: InitConfiguration) {
+function buildEndpointHost(initConfiguration: InitConfiguration, endpointType: EndpointType) {
   const { site = INTAKE_SITE_US1, internalAnalyticsSubdomain } = initConfiguration
 
   return site
@@ -83,10 +101,11 @@ function buildEndpointHost(initConfiguration: InitConfiguration) {
  */
 function buildEndpointParameters(
   { clientToken, internalAnalyticsSubdomain }: InitConfiguration,
-  trackType: TrackType,
+  endpointType: EndpointType,
   configurationTags: string[],
-  api: ApiType,
-  { retry, flushReason, encoding }: Payload
+  api: 'xhr' | 'fetch' | 'beacon',
+  flushReason: FlushReason | undefined,
+  retry: RetryInfo | undefined
 ) {
   const tags = [`sdk_version:${__BUILD_ENV__SDK_VERSION__}`, `api:${api}`].concat(configurationTags)
   if (flushReason && isExperimentalFeatureEnabled(ExperimentalFeature.COLLECT_FLUSH_REASON)) {
@@ -95,7 +114,6 @@ function buildEndpointParameters(
   if (retry) {
     tags.push(`retry_count:${retry.count}`, `retry_after:${retry.lastFailureStatus}`)
   }
-
   const parameters = [
     'o2source=browser',
     `o2tags=${encodeURIComponent(tags.join(','))}`,
@@ -105,14 +123,9 @@ function buildEndpointParameters(
     `o2-request-id=${generateUUID()}`,
   ]
 
-  if (encoding) {
-    parameters.push(`o2-evp-encoding=${encoding}`)
-  }
-
-  if (trackType === 'rum') {
+  if (endpointType === 'rum') {
     parameters.push(`batch_time=${timeStampNow()}`)
   }
-
   if (internalAnalyticsSubdomain) {
     parameters.reverse()
   }

package/src/domain/configuration/index.ts

@@ -5,6 +5,5 @@ export {
   validateAndBuildConfiguration,
   serializeConfiguration,
 } from './configuration'
-export { createEndpointBuilder, EndpointBuilder, TrackType } from './endpointBuilder'
+export { createEndpointBuilder, EndpointBuilder, EndpointType } from './endpointBuilder'
 export * from './intakeSites'
-export { computeTransportConfiguration } from './transportConfiguration'

package/src/domain/configuration/transportConfiguration.ts

@@ -42,7 +42,7 @@ function computeEndpointBuilders(initConfiguration: InitConfiguration, tags: str
   return {
     logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),
     rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay', tags),
+    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),
   }
 }
 

package/src/domain/console/consoleObservable.ts

@@ -1,3 +1,4 @@
+import { computeStackTrace } from '../tracekit'
 import { createHandlingStack, formatErrorMessage, toStackTraceString, tryToGetFingerprint } from '../error/error'
 import { mergeObservables, Observable } from '../../tools/observable'
 import { ConsoleApiName, globalConsole } from '../../tools/display'
@@ -5,7 +6,6 @@ import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import { find } from '../../tools/utils/polyfills'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
-import { computeStackTrace } from '../error/computeStackTrace'
 
 export interface ConsoleLog {
   message: string
@@ -33,7 +33,7 @@ export function resetConsoleObservable() {
 }
 
 function createConsoleObservable(api: ConsoleApiName) {
-  return new Observable<ConsoleLog>((observable) => {
+  const observable = new Observable<ConsoleLog>(() => {
     const originalConsoleApi = globalConsole[api]
 
     globalConsole[api] = (...params: unknown[]) => {
@@ -49,10 +49,13 @@ function createConsoleObservable(api: ConsoleApiName) {
       globalConsole[api] = originalConsoleApi
     }
   })
+
+  return observable
 }
 
 function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {
-  const message = params.map((param) => formatConsoleParameters(param)).join(' ')
+  // Todo: remove console error prefix in the next major version
+  let message = params.map((param) => formatConsoleParameters(param)).join(' ')
   let stack
   let fingerprint
 
@@ -60,6 +63,7 @@ function buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack:
     const firstErrorParam = find(params, (param: unknown): param is Error => param instanceof Error)
     stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined
     fingerprint = tryToGetFingerprint(firstErrorParam)
+    message = `console error: ${message}`
   }
 
   return {

package/src/domain/deflate/types.ts

@@ -1,5 +1,3 @@
-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.
@@ -41,15 +39,3 @@ 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/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,16 +1,7 @@
 import type { ClocksState } from '../../tools/utils/timeUtils'
 
-// 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 interface ErrorWithCause extends Error {
+  cause?: Error
 }
 
 export type RawErrorCause = {

package/src/domain/error/trackRuntimeError.ts

@@ -1,53 +1,21 @@
-import { instrumentMethod } from '../../tools/instrumentMethod'
 import type { Observable } from '../../tools/observable'
 import { clocksNow } from '../../tools/utils/timeUtils'
-import type { StackTrace } from './computeStackTrace'
-import { computeStackTrace, computeStackTraceFromOnErrorMessage } from './computeStackTrace'
+import { startUnhandledErrorCollection } from '../tracekit'
 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>) {
-  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)
+  return startUnhandledErrorCollection((stackTrace, originalError) => {
+    errorObservable.notify(
+      computeRawError({
+        stackTrace,
+        originalError,
+        startClocks: clocksNow(),
+        nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
+        source: ErrorSource.SOURCE,
+        handling: ErrorHandling.UNHANDLED,
+      })
+    )
   })
 }

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

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

package/src/domain/session/oldCookiesMigration.ts

@@ -1,4 +1,4 @@
-import { getInitCookie } from '../../browser/cookie'
+import { getCookie } 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 = getInitCookie(SESSION_STORE_KEY)
+  const sessionString = getCookie(SESSION_STORE_KEY)
   if (!sessionString) {
-    const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME)
-    const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME)
-    const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME)
+    const oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME)
+    const oldRumType = getCookie(OLD_RUM_COOKIE_NAME)
+    const oldLogsType = getCookie(OLD_LOGS_COOKIE_NAME)
     const session: SessionState = {}
 
     if (oldSessionId) {

package/src/domain/session/sessionStoreOperations.ts

@@ -1,5 +1,6 @@
 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'
@@ -19,7 +20,8 @@ export function processSessionStoreOperations(
   sessionStoreStrategy: SessionStoreStrategy,
   numberOfRetries = 0
 ) {
-  const { isLockEnabled, retrieveSession, persistSession, clearSession } = sessionStoreStrategy
+  const { retrieveSession, persistSession, clearSession } = sessionStoreStrategy
+  const lockEnabled = isLockEnabled()
 
   if (!ongoingOperations) {
     ongoingOperations = operations
@@ -28,13 +30,13 @@ export function processSessionStoreOperations(
     bufferedOperations.push(operations)
     return
   }
-  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+  if (lockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
     next(sessionStoreStrategy)
     return
   }
   let currentLock: string
   let currentSession = retrieveSession()
-  if (isLockEnabled) {
+  if (lockEnabled) {
     // if someone has lock, retry later
     if (currentSession.lock) {
       retryLater(operations, sessionStoreStrategy, numberOfRetries)
@@ -52,7 +54,7 @@ export function processSessionStoreOperations(
     }
   }
   let processedSession = operations.process(currentSession)
-  if (isLockEnabled) {
+  if (lockEnabled) {
     // if lock corrupted after process, retry later
     currentSession = retrieveSession()
     if (currentSession.lock !== currentLock!) {
@@ -68,7 +70,7 @@ export function processSessionStoreOperations(
       persistSession(processedSession)
     }
   }
-  if (isLockEnabled) {
+  if (lockEnabled) {
     // 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))) {
@@ -89,6 +91,12 @@ 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,4 +1,3 @@
-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'
@@ -16,11 +15,6 @@ 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),
@@ -51,13 +45,8 @@ function deleteSessionCookie(options: CookieOptions) {
 export function buildCookieOptions(initConfiguration: InitConfiguration) {
   const cookieOptions: CookieOptions = {}
 
-  cookieOptions.secure =
-    !!initConfiguration.useSecureSessionCookie ||
-    !!initConfiguration.usePartitionedCrossSiteSessionCookie ||
-    !!initConfiguration.useCrossSiteSessionCookie
-  cookieOptions.crossSite =
-    !!initConfiguration.usePartitionedCrossSiteSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
-  cookieOptions.partitioned = !!initConfiguration.usePartitionedCrossSiteSessionCookie
+  cookieOptions.secure = !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie
 
   if (initConfiguration.trackSessionAcrossSubdomains) {
     cookieOptions.domain = getCurrentSite()

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

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