@cloudcare/browser-core 3.2.51 → 3.3.4

package/src/helper/tools.js

@@ -764,9 +764,9 @@ export var sessionStorage = {
     var key = '__sensorsdatasupport__'
     var val = 'testIsSupportStorage'
     try {
-      if (sessionStorage && sessionStorage.setItem) {
-        sessionStorage.setItem(key, val)
-        sessionStorage.removeItem(key, val)
+      if (window.sessionStorage && window.sessionStorage.setItem) {
+        window.sessionStorage.setItem(key, val)
+        window.sessionStorage.removeItem(key, val)
         supported = true
       } else {
         supported = false
@@ -958,7 +958,7 @@ export var getHostname = function (url, defaultValue) {
   }
   var hostname = null
   try {
-    hostname = URL(url).hostname
+    hostname = new URL(url).hostname
   } catch (e) {}
   return hostname || defaultValue
 }

package/src/helper/valueHistory.js

@@ -20,7 +20,7 @@ export function createValueHistory(params) {
   var maxEntries = params.maxEntries
 
   var entries = []
-  if (cleanupHistoriesInterval) {
+  if (cleanupHistoriesInterval === null) {
     cleanupHistoriesInterval = setInterval(function () {
       return clearExpiredValues()
     }, CLEAR_OLD_VALUES_INTERVAL)

package/src/report/reportObservable.js

@@ -11,6 +11,8 @@ import {
 import { addEventListener } from '../browser/addEventListener'
 import { DOM_EVENT } from '../helper/enums'
 import { monitor } from '../helper/monitor'
+import { ErrorSource } from '../helper/errorTools'
+import { ErrorHandling } from '../helper/enums'
 export var RawReportType = {
   intervention: 'intervention',
   deprecation: 'deprecation',

package/src/session/sessionManagement.js

@@ -83,6 +83,7 @@ export function startSessionManager(
     findSession: function (startTime, options) {
       return sessionContextHistory.find(startTime, options)
     },
+    expandOrRenewSession: sessionStore.expandOrRenewSession,
     renewObservable,
     expireObservable,
     sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,

package/src/session/sessionStore.js

@@ -160,7 +160,10 @@ export function startSessionStore(
     processSessionStoreOperations(
       {
         process: function (sessionState) {
-          if (isSessionInNotStartedState(sessionState)) {
+          if (
+            isSessionInNotStartedState(sessionState) ||
+            isSessionInExpiredState(sessionState)
+          ) {
             return getExpiredSessionState()
           }
         },

package/src/synthetics/syntheticsWorkerValues.js

@@ -13,14 +13,16 @@ export function willSyntheticsInjectRum() {
 
 export function getSyntheticsTestId() {
   var value =
-    window._GUANCE_SYNTHETICS_PUBLIC_ID ||
-    getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+    typeof window._GUANCE_SYNTHETICS_PUBLIC_ID === 'string'
+      ? window._GUANCE_SYNTHETICS_PUBLIC_ID
+      : getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }
 
 export function getSyntheticsResultId() {
   var value =
-    window._GUANCE_SYNTHETICS_RESULT_ID ||
-    getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+    typeof window._GUANCE_SYNTHETICS_RESULT_ID === 'string'
+      ? window._GUANCE_SYNTHETICS_RESULT_ID
+      : getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }

package/src/transport/httpRequest.js

@@ -29,7 +29,7 @@ export function createHttpRequest(
   }
   var retryState = newRetryState(retryMaxSize)
   var sendStrategyForRetry = function (payload, onResponse) {
-    return fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onResponse)
+    return fetchStrategyWithFallback(endpointUrl, payload, onResponse)
   }
 
   return {
@@ -87,57 +87,19 @@ function reportBeaconError(e) {
     addTelemetryError(e)
   }
 }
-export function fetchKeepAliveStrategy(
+export function fetchStrategyWithFallback(
   endpointUrl,
-  bytesLimit,
   payload,
   onResponse
 ) {
-  var data = payload.data
-  var bytesCount = payload.bytesCount
   var url = addBatchPrecision(endpointUrl, payload.encoding)
-  var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit
-  if (canUseKeepAlive) {
-    var fetchOption = {
-      method: 'POST',
-      body: data,
-      keepalive: true,
-      mode: 'cors'
-    }
-    const headers = {
-      'x-client-timestamp': Date.now().toString()
-    }
-    if (payload.type) {
-      headers['Content-Type'] = payload.type
-    }
-    fetchOption.headers = headers
-    fetch(url, fetchOption)
-      .then(
-        monitor(function (response) {
-          if (typeof onResponse === 'function') {
-            onResponse({ status: response.status, type: response.type })
-          }
-        })
-      )
-      .catch(
-        monitor(function () {
-          fetchStrategy(url, payload, onResponse)
-        })
-      )
+  if (typeof fetch === 'function') {
+    sendFetch(url, payload, onResponse)
   } else {
     sendXHR(url, payload, onResponse)
   }
 }
 
-function isKeepAliveSupported() {
-  // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors
-  try {
-    return window.Request && 'keepalive' in new Request('http://a')
-  } catch {
-    return false
-  }
-}
-
 function sendXHR(url, payload, onResponse) {
   const data = payload.data
   const request = new XMLHttpRequest()
@@ -162,11 +124,10 @@ function sendXHR(url, payload, onResponse) {
   )
   request.send(data)
 }
-function fetchStrategy(url, payload, onResponse) {
+function sendFetch(url, payload, onResponse) {
   const fetchOption = {
     method: 'POST',
     body: payload.data,
-    keepalive: true,
     mode: 'cors'
   }
   const headers = {

package/types/index.d.ts

@@ -199,6 +199,12 @@ export interface RumBaseInitConfiguration extends InitConfiguration {
    * sessionReplay and compressIntakeRequests data compression are both done in the web worker thread, so by default, you need to allow worker-src blob: under CSP security access, or use workerUrl to host the worker address yourself
    */
   workerUrl?: string
+  /**
+   * Canvas snapshot encoding is done in a dedicated canvas worker thread. By
+   * default it uses an inlined blob worker, or you can host a separate
+   * canvas-worker bundle yourself for stricter CSP/security environments.
+   */
+  replayCanvasWorkerUrl?: string
   /**
    * Compress RUM data request content to reduce bandwidth usage when sending large amounts of data. Compression is done in the Worker thread.
    */
@@ -241,6 +247,74 @@ export interface RumBaseInitConfiguration extends InitConfiguration {
    * @returns true means mask the node, false means do not mask and continue privacyLevel logic
    */
   shouldMaskNode?: (node: Node, privacyLevel: NodePrivacyLevel) => boolean
+  /**
+   * Whether to enable canvas recording for session replay.
+   */
+  replayCanvasEnabled?: boolean | undefined
+  /**
+   * Canvas replay recording mode. Defaults to `auto`.
+   * `manual` records only when `snapshotCanvas()` is called.
+   * `auto` performs automatic canvas recording.
+   */
+  replayCanvasMode?: 'manual' | 'auto' | undefined
+  /**
+   * Canvas replay sampling strategy. A number means snapshot sampling at the configured rate.
+   * `'all'` enables 2D command capture, with automatic snapshot fallback for
+   * unsupported replay-fidelity cases. Defaults to a numeric sampling mode.
+   */
+  replayCanvasSampling?: 'all' | number | undefined
+  /**
+   * Encoded image mime type used for canvas snapshots.
+   */
+  replayCanvasMimeType?: string | undefined
+  /**
+   * Encoded image quality for canvas snapshots. Supports `low`, `medium`, `high`,
+   * or a number from 0 to 1 for advanced overrides.
+   */
+  replayCanvasQuality?: 'low' | 'medium' | 'high' | number | undefined
+  /**
+   * Maximum canvas edge size before downscaling for encoding.
+   */
+  replayCanvasMaxCanvasSize?: number | undefined
+  /**
+   * Maximum encoded bytes allowed for a single canvas snapshot.
+   */
+  replayCanvasMaxEncodedBytes?: number | undefined
+  /**
+   * Maximum number of concurrent canvas encoding tasks.
+   */
+  replayCanvasMaxConcurrentEncodes?: number | undefined
+  /**
+   * Whether canvas mutations should be flushed into a replay segment immediately.
+   */
+  replayCanvasFlushImmediately?: boolean | undefined
+  /**
+   * Auto snapshot interval in milliseconds when `replayCanvasMode` is `auto`.
+   */
+  replayCanvasAutoInterval?: number | undefined
+  /**
+   * Minimum cooldown in milliseconds after a successful auto snapshot.
+   */
+  replayCanvasAutoCooldown?: number | undefined
+  /**
+   * Backoff in milliseconds after an auto snapshot is skipped as unchanged.
+   */
+  replayCanvasAutoUnchangedBackoff?: number | undefined
+  /**
+   * Backoff in milliseconds after an auto snapshot fails.
+   */
+  replayCanvasAutoFailureBackoff?: number | undefined
+  /**
+   * Maximum number of canvases processed in a single auto snapshot run.
+   */
+  replayCanvasAutoMaxPerRun?: number | undefined
+  /**
+   * Controls whether a canvas should be recorded. Returning `false` skips the canvas.
+   * Returning a number assigns auto mode priority, where higher values are processed first.
+   */
+  shouldRecordCanvas?:
+    | ((canvas: HTMLCanvasElement) => boolean | number | undefined)
+    | undefined
 }
 export type RumInitConfiguration = RumBaseInitConfiguration &
   DatakitInitConfiguration