@cloudcare/browser-core 3.2.48 → 3.3.0

package/src/helper/errorTools.js

@@ -23,31 +23,34 @@ export function computeRawError(data) {
   var nonErrorPrefix = data.nonErrorPrefix
   var source = data.source
   var handling = data.handling
-  var isErrorInstance = originalError instanceof Error
+  var useFallbackStack =
+    data.useFallbackStack === undefined ? true : data.useFallbackStack
+  var isErrorInstance = isError(originalError)
+  if (!stackTrace && isErrorInstance) {
+    stackTrace = computeStackTrace(originalError)
+  }
   var message = computeMessage(
     stackTrace,
     isErrorInstance,
     nonErrorPrefix,
     originalError
   )
-  var stack = hasUsableStack(isErrorInstance, stackTrace)
-    ? toStackTraceString(stackTrace)
-    : NO_ERROR_STACK_PRESENT_MESSAGE
-  var causes = isErrorInstance
-    ? flattenErrorCauses(originalError, source)
-    : undefined
-  var type = stackTrace && stackTrace.name
-
   return {
     startClocks: startClocks,
     source: source,
     handling: handling,
     originalError: originalError,
     message: message,
-    stack: stack,
+    stack: stackTrace
+      ? toStackTraceString(stackTrace)
+      : useFallbackStack
+      ? NO_ERROR_STACK_PRESENT_MESSAGE
+      : undefined,
     handlingStack: handlingStack,
-    type: type,
-    causes: causes
+    type: stackTrace ? stackTrace.name : undefined,
+    causes: isErrorInstance
+      ? flattenErrorCauses(originalError, source)
+      : undefined
   }
 }
 function computeMessage(
@@ -177,3 +180,10 @@ export function flattenErrorCauses(error, parentSource) {
   }
   return causes.length ? causes : undefined
 }
+
+export function isError(error) {
+  return (
+    error instanceof Error ||
+    Object.prototype.toString.call(error) === '[object Error]'
+  )
+}

package/src/helper/monitor.js

@@ -25,17 +25,19 @@ export function callMonitored(fn, context, args) {
   try {
     return fn.apply(context, args)
   } catch (e) {
-    displayIfDebugEnabled(e)
-    if (onMonitorErrorCollected) {
-      try {
-        onMonitorErrorCollected(e)
-      } catch (e) {
-        displayIfDebugEnabled(e)
-      }
+    monitorError(e)
+  }
+}
+export function monitorError(e) {
+  displayIfDebugEnabled(e)
+  if (onMonitorErrorCollected) {
+    try {
+      onMonitorErrorCollected(e)
+    } catch (e) {
+      displayIfDebugEnabled(e)
     }
   }
 }
-
 export function displayIfDebugEnabled() {
   var args = [].slice.call(arguments)
   //   display.error.apply(null, ['[MONITOR]'].concat(args))

package/src/helper/polyfills.js

@@ -5,7 +5,7 @@ export function WeakSet(initialValues) {
   if (initialValues) {
     initialValues.forEach(function (value) {
       this.map.set(value, PLACEHOLDER)
-    })
+    }, this)
   }
 }
 WeakSet.prototype.add = function (value) {

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/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