@kubesense/kubesense-browser-rum-core 1.8.0 → 2.0.0-beta.1

package/cjs/domain/configuration/remoteConfiguration.types.d.ts

@@ -20,11 +20,26 @@ export type DynamicOption = {
     attribute?: string;
     extractor?: SerializedRegex;
     [k: string]: unknown;
+} | {
+    rcSerializedType: 'dynamic';
+    strategy: 'localStorage';
+    key: string;
+    extractor?: SerializedRegex;
+    [k: string]: unknown;
 };
 /**
  * RUM Browser & Mobile SDKs Remote Configuration properties
  */
 export interface RumSdkConfig {
+    /**
+     * Profiling feature Remote Configuration properties
+     */
+    profiling?: {
+        /**
+         * The percentage of users profiled
+         */
+        sampleRate?: number;
+    };
     /**
      * RUM feature Remote Configuration properties
      */
@@ -63,6 +78,12 @@ export interface RumSdkConfig {
             attribute?: string;
             extractor?: SerializedRegex;
             [k: string]: unknown;
+        } | {
+            rcSerializedType: 'dynamic';
+            strategy: 'localStorage';
+            key: string;
+            extractor?: SerializedRegex;
+            [k: string]: unknown;
         };
         /**
          * The percentage of sessions tracked
@@ -72,6 +93,34 @@ export interface RumSdkConfig {
          * The percentage of sessions with RUM & Session Replay pricing tracked
          */
         sessionReplaySampleRate?: number;
+        /**
+         * The percentage of telemetry events sampled
+         */
+        telemetrySampleRate?: number;
+        /**
+         * Whether to track anonymous users
+         */
+        trackAnonymousUser?: boolean;
+        /**
+         * Whether to automatically collect user actions
+         */
+        trackUserInteractions?: boolean;
+        /**
+         * Whether to collect resource events
+         */
+        trackResources?: boolean;
+        /**
+         * Whether to collect long task events
+         */
+        trackLongTasks?: boolean;
+        /**
+         * Controls when tracing headers are injected
+         */
+        traceContextInjection?: 'all' | 'sampled';
+        /**
+         * HTML attribute used as the RUM action name
+         */
+        actionNameAttribute?: string;
         /**
          * Session replay default privacy level
          */

package/cjs/domain/configuration/remoteConfigurationCache.d.ts

@@ -0,0 +1,42 @@
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time';
+import type { RemoteConfiguration } from './remoteConfiguration';
+export declare const CACHE_VERSION = 3;
+export declare const CACHE_KEY_PREFIX = "dd_rc_";
+/**
+ * Sync metadata for the cached configuration version, reported on configuration telemetry to
+ * measure how long a published configuration takes to take effect.
+ */
+export interface RemoteConfigurationMetadata {
+    /** CDN publish time, from the `last-modified` response header. */
+    lastModified?: number;
+    /** When the SDK fetched the version currently cached. */
+    lastSynced: TimeStamp;
+    /** When this version was first applied. Stamped once, then reused on every later page load. */
+    firstApplied?: TimeStamp;
+    /** Identifies one sync, so repeat page loads from a device collapse into a single unit. */
+    syncId: string;
+}
+export type CacheReadStatus = 'hit' | 'miss' | 'error';
+export interface CacheHitResult {
+    status: Extract<CacheReadStatus, 'hit'>;
+    config: RemoteConfiguration;
+    metadata: RemoteConfigurationMetadata;
+}
+export type CacheReadResult = {
+    status: Exclude<CacheReadStatus, 'hit'>;
+} | CacheHitResult;
+export declare const CACHE_STATUS_TO_METRIC_MAP: Record<CacheReadStatus, 'success' | 'missing' | 'failure'>;
+export declare function buildCacheKey(remoteConfigurationId: string): string;
+export declare function createConfigurationCache({ remoteConfigurationId }: {
+    remoteConfigurationId: string;
+}): {
+    read(): CacheReadResult;
+    remove(): void;
+    write(config: RemoteConfiguration, lastModified?: number): void;
+    /**
+     * Records when this configuration version was first put into effect. Stamped on the first page
+     * load that applies it, then reused by every later one, so the reported value marks a fixed
+     * point in time instead of drifting with each page load.
+     */
+    stampFirstApplied(cached: CacheHitResult): RemoteConfigurationMetadata;
+};

package/cjs/domain/configuration/remoteConfigurationCache.js

@@ -0,0 +1,95 @@
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+const CACHE_KEY_PREFIX = "dd_rc_";
+const CACHE_STATUS_TO_METRIC_MAP = {
+	hit: "success",
+	miss: "missing",
+	error: "failure"
+};
+function buildCacheKey(remoteConfigurationId) {
+	return `${CACHE_KEY_PREFIX}${remoteConfigurationId}`;
+}
+function isValidCacheEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const hasVersion = "version" in value && value.version === 3;
+	const hasConfig = "config" in value && typeof value.config === "object" && value.config !== null;
+	const hasMetadata = "metadata" in value && (0, _kubesense_kubesense_js_core_util.isIndexableObject)(value.metadata) && typeof value.metadata.syncId === "string" && typeof value.metadata.lastSynced === "number";
+	return hasVersion && hasConfig && hasMetadata;
+}
+function persist(key, entry) {
+	try {
+		localStorage.setItem(key, JSON.stringify(entry));
+	} catch {}
+}
+function createConfigurationCache({ remoteConfigurationId }) {
+	const key = buildCacheKey(remoteConfigurationId);
+	return {
+		read() {
+			let raw;
+			try {
+				raw = localStorage.getItem(key);
+			} catch {
+				return { status: "error" };
+			}
+			if (raw === null) return { status: "miss" };
+			const parsed = (0, _kubesense_kubesense_browser_core.tryJsonParse)(raw);
+			if (parsed === void 0) {
+				this.remove();
+				return { status: "error" };
+			}
+			if (!isValidCacheEntry(parsed)) {
+				this.remove();
+				return { status: "error" };
+			}
+			return {
+				status: "hit",
+				config: parsed.config,
+				metadata: parsed.metadata
+			};
+		},
+		remove() {
+			try {
+				localStorage.removeItem(key);
+			} catch {}
+		},
+		write(config, lastModified) {
+			const cached = this.read();
+			if (cached.status === "hit" && JSON.stringify(cached.config) === JSON.stringify(config)) return;
+			persist(key, {
+				version: 3,
+				config,
+				metadata: {
+					lastModified,
+					lastSynced: (0, _kubesense_kubesense_js_core_time.timeStampNow)(),
+					syncId: (0, _kubesense_kubesense_browser_core.generateUUID)()
+				}
+			});
+		},
+		/**
+		* Records when this configuration version was first put into effect. Stamped on the first page
+		* load that applies it, then reused by every later one, so the reported value marks a fixed
+		* point in time instead of drifting with each page load.
+		*/
+		stampFirstApplied(cached) {
+			if (cached.metadata.firstApplied !== void 0) return cached.metadata;
+			const metadata = {
+				...cached.metadata,
+				firstApplied: (0, _kubesense_kubesense_js_core_time.timeStampNow)()
+			};
+			persist(key, {
+				version: 3,
+				config: cached.config,
+				metadata
+			});
+			return metadata;
+		}
+	};
+}
+//#endregion
+exports.CACHE_KEY_PREFIX = CACHE_KEY_PREFIX;
+exports.CACHE_STATUS_TO_METRIC_MAP = CACHE_STATUS_TO_METRIC_MAP;
+exports.buildCacheKey = buildCacheKey;
+exports.createConfigurationCache = createConfigurationCache;
+
+//# sourceMappingURL=remoteConfigurationCache.js.map

package/cjs/domain/configuration/remoteConfigurationCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteConfigurationCache.js","names":["isIndexableObject","tryJsonParse","timeStampNow","generateUUID"],"sources":["../../../src/domain/configuration/remoteConfigurationCache.ts"],"sourcesContent":["import { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport { generateUUID, tryJsonParse } from '@kubesense/kubesense-browser-core'\nimport { isIndexableObject } from '@kubesense/kubesense-js-core/util'\nimport type { TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport type { RemoteConfiguration } from './remoteConfiguration'\n\nexport const CACHE_VERSION = 3\nexport const CACHE_KEY_PREFIX = 'dd_rc_'\n\n/**\n * Sync metadata for the cached configuration version, reported on configuration telemetry to\n * measure how long a published configuration takes to take effect.\n */\nexport interface RemoteConfigurationMetadata {\n  /** CDN publish time, from the `last-modified` response header. */\n  lastModified?: number\n  /** When the SDK fetched the version currently cached. */\n  lastSynced: TimeStamp\n  /** When this version was first applied. Stamped once, then reused on every later page load. */\n  firstApplied?: TimeStamp\n  /** Identifies one sync, so repeat page loads from a device collapse into a single unit. */\n  syncId: string\n}\n\ninterface CachedRemoteConfiguration {\n  version: number\n  config: RemoteConfiguration\n  metadata: RemoteConfigurationMetadata\n}\n\nexport type CacheReadStatus = 'hit' | 'miss' | 'error'\n\nexport interface CacheHitResult {\n  status: Extract<CacheReadStatus, 'hit'>\n  config: RemoteConfiguration\n  metadata: RemoteConfigurationMetadata\n}\n\nexport type CacheReadResult =\n  | {\n      status: Exclude<CacheReadStatus, 'hit'>\n    }\n  | CacheHitResult\n\nexport const CACHE_STATUS_TO_METRIC_MAP: Record<CacheReadStatus, 'success' | 'missing' | 'failure'> = {\n  hit: 'success',\n  miss: 'missing',\n  error: 'failure',\n}\n\nexport function buildCacheKey(remoteConfigurationId: string): string {\n  return `${CACHE_KEY_PREFIX}${remoteConfigurationId}`\n}\n\nfunction isValidCacheEntry(value: unknown): value is CachedRemoteConfiguration {\n  if (typeof value !== 'object' || value === null) {\n    return false\n  }\n\n  const hasVersion = 'version' in value && value.version === CACHE_VERSION\n  const hasConfig = 'config' in value && typeof value.config === 'object' && value.config !== null\n  const hasMetadata =\n    'metadata' in value &&\n    isIndexableObject(value.metadata) &&\n    typeof value.metadata.syncId === 'string' &&\n    typeof value.metadata.lastSynced === 'number'\n\n  return hasVersion && hasConfig && hasMetadata\n}\n\nfunction persist(key: string, entry: CachedRemoteConfiguration) {\n  try {\n    localStorage.setItem(key, JSON.stringify(entry))\n  } catch {\n    // Ignore\n  }\n}\n\nexport function createConfigurationCache({ remoteConfigurationId }: { remoteConfigurationId: string }) {\n  const key = buildCacheKey(remoteConfigurationId)\n\n  return {\n    read(): CacheReadResult {\n      let raw: string | null\n\n      try {\n        raw = localStorage.getItem(key)\n      } catch {\n        return { status: 'error' }\n      }\n\n      if (raw === null) {\n        return { status: 'miss' }\n      }\n\n      const parsed = tryJsonParse(raw)\n      if (parsed === undefined) {\n        this.remove()\n\n        return { status: 'error' }\n      }\n\n      if (!isValidCacheEntry(parsed)) {\n        this.remove()\n\n        return { status: 'error' }\n      }\n\n      return { status: 'hit', config: parsed.config, metadata: parsed.metadata }\n    },\n    remove() {\n      try {\n        localStorage.removeItem(key)\n      } catch {\n        // Ignore\n      }\n    },\n    write(config: RemoteConfiguration, lastModified?: number) {\n      const cached = this.read()\n\n      // Only a payload change counts as a sync. The SDK sends no `If-None-Match`, so it never\n      // observes a 304 and cannot otherwise tell a genuine sync from a repeated fetch of the same\n      // version. Skipping the write here is also what keeps `firstApplied` alive across refetches.\n      // TODO: compare on `ETag` instead once the CDN exposes it through\n      // `Access-Control-Expose-Headers`. The stringify compare is key-order sensitive, which holds\n      // only because both sides come from `JSON.parse` of the same CDN payload.\n      if (cached.status === 'hit' && JSON.stringify(cached.config) === JSON.stringify(config)) {\n        return\n      }\n\n      persist(key, {\n        version: CACHE_VERSION,\n        config,\n        metadata: { lastModified, lastSynced: timeStampNow(), syncId: generateUUID() },\n      })\n    },\n    /**\n     * Records when this configuration version was first put into effect. Stamped on the first page\n     * load that applies it, then reused by every later one, so the reported value marks a fixed\n     * point in time instead of drifting with each page load.\n     */\n    stampFirstApplied(cached: CacheHitResult): RemoteConfigurationMetadata {\n      if (cached.metadata.firstApplied !== undefined) {\n        return cached.metadata\n      }\n\n      const metadata: RemoteConfigurationMetadata = { ...cached.metadata, firstApplied: timeStampNow() }\n      persist(key, { version: CACHE_VERSION, config: cached.config, metadata })\n\n      return metadata\n    },\n  }\n}\n"],"mappings":";;;AAOA,MAAa,mBAAmB;AAqChC,MAAa,6BAAyF;CACpG,KAAK;CACL,MAAM;CACN,OAAO;AACT;AAEA,SAAgB,cAAc,uBAAuC;CACnE,OAAO,GAAG,mBAAmB;AAC/B;AAEA,SAAS,kBAAkB,OAAoD;CAC7E,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CAGT,MAAM,aAAa,aAAa,SAAS,MAAM,YAAA;CAC/C,MAAM,YAAY,YAAY,SAAS,OAAO,MAAM,WAAW,YAAY,MAAM,WAAW;CAC5F,MAAM,cACJ,cAAc,UAAA,GACdA,kCAAAA,kBAAAA,CAAkB,MAAM,QAAQ,KAChC,OAAO,MAAM,SAAS,WAAW,YACjC,OAAO,MAAM,SAAS,eAAe;CAEvC,OAAO,cAAc,aAAa;AACpC;AAEA,SAAS,QAAQ,KAAa,OAAkC;CAC9D,IAAI;EACF,aAAa,QAAQ,KAAK,KAAK,UAAU,KAAK,CAAC;CACjD,QAAQ,CAER;AACF;AAEA,SAAgB,yBAAyB,EAAE,yBAA4D;CACrG,MAAM,MAAM,cAAc,qBAAqB;CAE/C,OAAO;EACL,OAAwB;GACtB,IAAI;GAEJ,IAAI;IACF,MAAM,aAAa,QAAQ,GAAG;GAChC,QAAQ;IACN,OAAO,EAAE,QAAQ,QAAQ;GAC3B;GAEA,IAAI,QAAQ,MACV,OAAO,EAAE,QAAQ,OAAO;GAG1B,MAAM,UAAA,GAASC,kCAAAA,aAAAA,CAAa,GAAG;GAC/B,IAAI,WAAW,KAAA,GAAW;IACxB,KAAK,OAAO;IAEZ,OAAO,EAAE,QAAQ,QAAQ;GAC3B;GAEA,IAAI,CAAC,kBAAkB,MAAM,GAAG;IAC9B,KAAK,OAAO;IAEZ,OAAO,EAAE,QAAQ,QAAQ;GAC3B;GAEA,OAAO;IAAE,QAAQ;IAAO,QAAQ,OAAO;IAAQ,UAAU,OAAO;GAAS;EAC3E;EACA,SAAS;GACP,IAAI;IACF,aAAa,WAAW,GAAG;GAC7B,QAAQ,CAER;EACF;EACA,MAAM,QAA6B,cAAuB;GACxD,MAAM,SAAS,KAAK,KAAK;GAQzB,IAAI,OAAO,WAAW,SAAS,KAAK,UAAU,OAAO,MAAM,MAAM,KAAK,UAAU,MAAM,GACpF;GAGF,QAAQ,KAAK;IACX,SAAA;IACA;IACA,UAAU;KAAE;KAAc,aAAA,GAAYC,kCAAAA,aAAAA,CAAa;KAAG,SAAA,GAAQC,kCAAAA,aAAAA,CAAa;IAAE;GAC/E,CAAC;EACH;;;;;;EAMA,kBAAkB,QAAqD;GACrE,IAAI,OAAO,SAAS,iBAAiB,KAAA,GACnC,OAAO,OAAO;GAGhB,MAAM,WAAwC;IAAE,GAAG,OAAO;IAAU,eAAA,GAAcD,kCAAAA,aAAAA,CAAa;GAAE;GACjG,QAAQ,KAAK;IAAE,SAAA;IAAwB,QAAQ,OAAO;IAAQ;GAAS,CAAC;GAExE,OAAO;EACT;CACF;AACF"}

package/cjs/domain/configuration/remoteSdkConfiguration.d.ts

@@ -5,12 +5,21 @@ export interface RemoteSdkConfigurationResult {
     /** `false` when the dashboard has switched RUM off entirely. */
     rumEnabled: boolean;
 }
+/** The context managers the document can contribute to. */
+export interface RemoteSdkConfigurationContexts {
+    globalContext?: {
+        setContextProperty: (key: string, value: unknown) => void;
+    };
+    userContext?: {
+        setContextProperty: (key: string, value: unknown) => void;
+    };
+}
 /**
  * Read the cached document and merge it into the init configuration. Synchronous and
  * network-free: this runs on the initialization path.
  */
-export declare function applyCachedSdkConfiguration(initConfiguration: RumInitConfiguration): RemoteSdkConfigurationResult;
-export declare function applySdkConfiguration(initConfiguration: RumInitConfiguration, remoteConfig: RemoteSdkConfig): RemoteSdkConfigurationResult;
+export declare function applyCachedSdkConfiguration(initConfiguration: RumInitConfiguration, contexts?: RemoteSdkConfigurationContexts): RemoteSdkConfigurationResult;
+export declare function applySdkConfiguration(initConfiguration: RumInitConfiguration, remoteConfig: RemoteSdkConfig, contexts?: RemoteSdkConfigurationContexts): RemoteSdkConfigurationResult;
 /**
  * Refresh the cache for the next page load. Must be called *after* the SDK has started so it
  * never delays initialization.

package/cjs/domain/configuration/remoteSdkConfiguration.js

@@ -1,142 +1,210 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyCachedSdkConfiguration = applyCachedSdkConfiguration;
-exports.applySdkConfiguration = applySdkConfiguration;
-exports.scheduleSdkConfigurationRefresh = scheduleSdkConfigurationRefresh;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+const require_configuration = require("./configuration.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/configuration/remoteSdkConfiguration.ts
+const PROPAGATOR_TYPES = [
+	"kubesense",
+	"b3",
+	"b3multi",
+	"tracecontext"
+];
 /**
- * Applies the dashboard-managed configuration document to the user's init configuration.
- *
- * Only scalar settings travel: anything that is a function or a matcher (`beforeSend`,
- * `allowedTracingUrls`, `excludedActivityUrls`, plugins) stays in application code. Identity and
- * endpoint settings (`clientToken`, `applicationId`, `kubesenseRumEndpoint`, `proxy`) are also
- * excluded — they determine where the configuration request itself goes, and letting them be
- * remotely rewritten would be a redirection risk.
- *
- * Every field is applied only when present and valid, so the user's own init configuration —
- * and failing that, the SDK default — always wins over a missing or malformed remote value.
- */
+* Applies the dashboard-managed configuration document to the user's init configuration.
+*
+* Only scalar settings travel: anything that is a function or a matcher (`beforeSend`,
+* `allowedTracingUrls`, `excludedActivityUrls`, plugins) stays in application code. Identity and
+* endpoint settings (`clientToken`, `applicationId`, `kubesenseRumEndpoint`, `proxy`) are also
+* excluded — they determine where the configuration request itself goes, and letting them be
+* remotely rewritten would be a redirection risk.
+*
+* Every field is applied only when present and valid, so the user's own init configuration —
+* and failing that, the SDK default — always wins over a missing or malformed remote value.
+*/
 const PRIVACY_LEVELS = [
-    kubesense_browser_core_1.DefaultPrivacyLevel.ALLOW,
-    kubesense_browser_core_1.DefaultPrivacyLevel.MASK,
-    kubesense_browser_core_1.DefaultPrivacyLevel.MASK_USER_INPUT,
+	_kubesense_kubesense_browser_core.DefaultPrivacyLevel.ALLOW,
+	_kubesense_kubesense_browser_core.DefaultPrivacyLevel.MASK,
+	_kubesense_kubesense_browser_core.DefaultPrivacyLevel.MASK_USER_INPUT,
+	_kubesense_kubesense_browser_core.DefaultPrivacyLevel.MASK_UNLESS_ALLOWLISTED
+];
+const TRACE_CONTEXT_INJECTIONS = [_kubesense_kubesense_browser_core.TraceContextInjection.ALL, _kubesense_kubesense_browser_core.TraceContextInjection.SAMPLED];
+const CANVAS_RECORDING_QUALITIES = [
+	require_configuration.CanvasRecordingQuality.LOW,
+	require_configuration.CanvasRecordingQuality.MEDIUM,
+	require_configuration.CanvasRecordingQuality.HIGH
 ];
-const TRACE_CONTEXT_INJECTIONS = [kubesense_browser_core_1.TraceContextInjection.ALL, kubesense_browser_core_1.TraceContextInjection.SAMPLED];
 /**
- * Read the cached document and merge it into the init configuration. Synchronous and
- * network-free: this runs on the initialization path.
- */
-function applyCachedSdkConfiguration(initConfiguration) {
-    const remoteConfig = (0, kubesense_browser_core_1.getCachedSdkConfig)();
-    if (!remoteConfig) {
-        return { initConfiguration, rumEnabled: true };
-    }
-    return applySdkConfiguration(initConfiguration, remoteConfig);
+* Read the cached document and merge it into the init configuration. Synchronous and
+* network-free: this runs on the initialization path.
+*/
+function applyCachedSdkConfiguration(initConfiguration, contexts) {
+	const remoteConfig = (0, _kubesense_kubesense_browser_core.getCachedSdkConfig)(initConfiguration.clientToken);
+	if (!remoteConfig) return {
+		initConfiguration,
+		rumEnabled: true
+	};
+	return applySdkConfiguration(initConfiguration, remoteConfig, contexts);
 }
-function applySdkConfiguration(initConfiguration, remoteConfig) {
-    const features = remoteConfig.features;
-    if ((0, kubesense_browser_core_1.readBoolean)(features, 'rum') === false) {
-        return { initConfiguration, rumEnabled: false };
-    }
-    const applied = { ...initConfiguration };
-    applyRumSection(applied, remoteConfig.rum);
-    applySessionReplaySection(applied, remoteConfig.sessionReplay);
-    applyProfilingSection(applied, remoteConfig.profiling);
-    applyFeatureSwitches(applied, features);
-    return { initConfiguration: applied, rumEnabled: true };
+function applySdkConfiguration(initConfiguration, remoteConfig, contexts) {
+	const features = remoteConfig.features;
+	if ((0, _kubesense_kubesense_browser_core.readBoolean)(features, "rum") === false) return {
+		initConfiguration,
+		rumEnabled: false
+	};
+	const applied = { ...initConfiguration };
+	applyRumSection(applied, remoteConfig.rum);
+	applyContexts(remoteConfig.rum, contexts);
+	applySessionReplaySection(applied, remoteConfig.sessionReplay);
+	applyProfilingSection(applied, remoteConfig.profiling);
+	applyFeatureSwitches(applied, features);
+	return {
+		initConfiguration: applied,
+		rumEnabled: true
+	};
 }
 function applyRumSection(applied, rum) {
-    if (!rum) {
-        return;
-    }
-    assign(applied, 'sessionSampleRate', (0, kubesense_browser_core_1.readSampleRate)(rum, 'sessionSampleRate'));
-    assign(applied, 'telemetrySampleRate', (0, kubesense_browser_core_1.readSampleRate)(rum, 'telemetrySampleRate'));
-    assign(applied, 'traceSampleRate', (0, kubesense_browser_core_1.readSampleRate)(rum, 'traceSampleRate'));
-    assign(applied, 'trackUserInteractions', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackUserInteractions'));
-    assign(applied, 'trackResources', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackResources'));
-    assign(applied, 'trackLongTasks', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackLongTasks'));
-    assign(applied, 'trackViewsManually', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackViewsManually'));
-    assign(applied, 'trackBfcacheViews', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackBfcacheViews'));
-    assign(applied, 'trackAnonymousUser', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackAnonymousUser'));
-    assign(applied, 'trackSessionAcrossSubdomains', (0, kubesense_browser_core_1.readBoolean)(rum, 'trackSessionAcrossSubdomains'));
-    assign(applied, 'enablePrivacyForActionName', (0, kubesense_browser_core_1.readBoolean)(rum, 'enablePrivacyForActionName'));
-    assign(applied, 'propagateTraceBaggage', (0, kubesense_browser_core_1.readBoolean)(rum, 'propagateTraceBaggage'));
-    assign(applied, 'defaultPrivacyLevel', (0, kubesense_browser_core_1.readEnum)(rum, 'defaultPrivacyLevel', PRIVACY_LEVELS));
-    assign(applied, 'traceContextInjection', (0, kubesense_browser_core_1.readEnum)(rum, 'traceContextInjection', TRACE_CONTEXT_INJECTIONS));
-    assign(applied, 'actionNameAttribute', (0, kubesense_browser_core_1.readString)(rum, 'actionNameAttribute'));
-    assign(applied, 'service', (0, kubesense_browser_core_1.readString)(rum, 'service'));
-    assign(applied, 'env', (0, kubesense_browser_core_1.readString)(rum, 'env'));
-    assign(applied, 'version', (0, kubesense_browser_core_1.readString)(rum, 'version'));
+	if (!rum) return;
+	assign(applied, "sessionSampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(rum, "sessionSampleRate"));
+	assign(applied, "telemetrySampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(rum, "telemetrySampleRate"));
+	assign(applied, "traceSampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(rum, "traceSampleRate"));
+	assign(applied, "trackUserInteractions", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackUserInteractions"));
+	assign(applied, "trackResources", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackResources"));
+	assign(applied, "trackLongTasks", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackLongTasks"));
+	assign(applied, "trackViewsManually", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackViewsManually"));
+	assign(applied, "trackAnonymousUser", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackAnonymousUser"));
+	assign(applied, "trackSessionAcrossSubdomains", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackSessionAcrossSubdomains"));
+	assign(applied, "enablePrivacyForActionName", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "enablePrivacyForActionName"));
+	assign(applied, "propagateTraceBaggage", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "propagateTraceBaggage"));
+	assign(applied, "defaultPrivacyLevel", (0, _kubesense_kubesense_browser_core.readEnum)(rum, "defaultPrivacyLevel", PRIVACY_LEVELS));
+	assign(applied, "traceContextInjection", (0, _kubesense_kubesense_browser_core.readEnum)(rum, "traceContextInjection", TRACE_CONTEXT_INJECTIONS));
+	assign(applied, "actionNameAttribute", (0, _kubesense_kubesense_browser_core.readString)(rum, "actionNameAttribute"));
+	assign(applied, "betaEnableViewUpdates", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "betaEnableViewUpdates"));
+	assign(applied, "betaTrackWebSockets", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "betaTrackWebSockets"));
+	assign(applied, "trackResourceHeaders", (0, _kubesense_kubesense_browser_core.readBoolean)(rum, "trackResourceHeaders"));
+	assign(applied, "allowedTracingUrls", readTracingUrls(rum.allowedTracingUrls));
+	assign(applied, "allowedTrackingOrigins", (0, _kubesense_kubesense_browser_core.readStringList)(rum.allowedTrackingOrigins));
+	assign(applied, "service", (0, _kubesense_kubesense_browser_core.readString)(rum, "service"));
+	assign(applied, "env", (0, _kubesense_kubesense_browser_core.readString)(rum, "env"));
+	assign(applied, "version", (0, _kubesense_kubesense_browser_core.readString)(rum, "version"));
+}
+/**
+* Tracing URLs arriving as JSON can only be plain strings (prefix matches), optionally paired with
+* the propagators to inject. As with route rules, regexes and functions stay in application code:
+* they cannot be expressed safely in JSON, and this list decides which cross-origin requests get
+* tracing headers attached — a pattern that is broader than intended leaks trace ids to third
+* parties and can break their CORS preflight.
+*/
+function readTracingUrls(value) {
+	if (!Array.isArray(value)) return;
+	const options = [];
+	for (const entry of value) {
+		if (typeof entry === "string" && entry.length > 0) {
+			options.push(entry);
+			continue;
+		}
+		if (!(0, _kubesense_kubesense_js_core_util.isIndexableObject)(entry)) continue;
+		const match = (0, _kubesense_kubesense_browser_core.readString)(entry, "match");
+		if (!match) continue;
+		const propagatorTypes = (0, _kubesense_kubesense_browser_core.readStringList)(entry.propagatorTypes)?.filter((propagator) => PROPAGATOR_TYPES.includes(propagator));
+		options.push(propagatorTypes?.length ? {
+			match,
+			propagatorTypes
+		} : { match });
+	}
+	return options.length > 0 ? options : void 0;
+}
+/**
+* Properties from the document are set individually rather than replacing the whole context, so
+* anything the application has already attached with `setGlobalContext()` / `setUser()` survives.
+*
+* The user is applied here, before `startUserContext()` installs its change subscription, so a
+* remotely-supplied identity behaves exactly like an application calling `setUser()` at the top of
+* its bootstrap: it becomes the session owner rather than looking like a mid-session user switch.
+* Changing the user in the dashboard therefore expires the session once, on the first load that
+* reads the new document — which is the intended behaviour for a user change — and steady-state
+* loads leave the session alone.
+*/
+function applyContexts(rum, contexts) {
+	applyContextProperties(contexts?.globalContext, rum?.context);
+	applyContextProperties(contexts?.userContext, rum?.user);
+}
+function applyContextProperties(contextManager, properties) {
+	if (!contextManager || !(0, _kubesense_kubesense_js_core_util.isIndexableObject)(properties)) return;
+	for (const [key, value] of Object.entries(properties)) contextManager.setContextProperty(key, value);
 }
 function applySessionReplaySection(applied, sessionReplay) {
-    if (!sessionReplay) {
-        return;
-    }
-    assign(applied, 'sessionReplaySampleRate', (0, kubesense_browser_core_1.readSampleRate)(sessionReplay, 'sampleRate'));
-    assign(applied, 'startSessionReplayRecordingManually', (0, kubesense_browser_core_1.readBoolean)(sessionReplay, 'startRecordingManually'));
-    assign(applied, 'defaultPrivacyLevel', (0, kubesense_browser_core_1.readEnum)(sessionReplay, 'defaultPrivacyLevel', PRIVACY_LEVELS));
-    assign(applied, 'sessionReplayRoutes', readRoutes(sessionReplay.routes));
+	if (!sessionReplay) return;
+	assign(applied, "sessionReplaySampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(sessionReplay, "sampleRate"));
+	assign(applied, "startSessionReplayRecordingManually", (0, _kubesense_kubesense_browser_core.readBoolean)(sessionReplay, "startRecordingManually"));
+	assign(applied, "defaultPrivacyLevel", (0, _kubesense_kubesense_browser_core.readEnum)(sessionReplay, "defaultPrivacyLevel", PRIVACY_LEVELS));
+	assign(applied, "sessionReplayRoutes", readRoutes(sessionReplay.routes));
+	assign(applied, "sessionReplayCanvasRecording", readCanvasRecording(sessionReplay.canvasRecording));
 }
 /**
- * Route rules arriving as JSON can only be plain strings (prefix matches). Regexes and functions
- * are deliberately not accepted from the dashboard: they cannot be expressed safely in JSON and a
- * pathological pattern would run on every view change.
- */
-function readRoutes(routes) {
-    if (!routes || typeof routes !== 'object' || Array.isArray(routes)) {
-        return undefined;
-    }
-    const include = readStringList(routes.include);
-    const exclude = readStringList(routes.exclude);
-    if (!include && !exclude) {
-        return undefined;
-    }
-    return { include, exclude };
+* Canvas capture is the most expensive replay setting there is — it uploads rendered frames — so it
+* is only enabled when the document says so explicitly, and each limit is validated against the
+* range the SDK accepts instead of being clamped.
+*/
+function readCanvasRecording(canvasRecording) {
+	if (!(0, _kubesense_kubesense_js_core_util.isIndexableObject)(canvasRecording)) return;
+	const enable = (0, _kubesense_kubesense_browser_core.readBoolean)(canvasRecording, "enable");
+	if (enable === void 0) return;
+	return {
+		enable,
+		quality: (0, _kubesense_kubesense_browser_core.readEnum)(canvasRecording, "quality", CANVAS_RECORDING_QUALITIES),
+		maxFramesPerSecond: (0, _kubesense_kubesense_browser_core.readNumberInRange)(canvasRecording, "maxFramesPerSecond", 0, 8),
+		hashingMaxDimension: (0, _kubesense_kubesense_browser_core.readNumberInRange)(canvasRecording, "hashingMaxDimension", 1, 100),
+		maxImageDimension: (0, _kubesense_kubesense_browser_core.readNumberInRange)(canvasRecording, "maxImageDimension", 1, 1280)
+	};
 }
-function readStringList(value) {
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    const strings = value.filter((item) => typeof item === 'string' && item.length > 0);
-    return strings.length > 0 ? strings : undefined;
+/**
+* Route rules arriving as JSON can only be plain strings (prefix matches). Regexes and functions
+* are deliberately not accepted from the dashboard: they cannot be expressed safely in JSON and a
+* pathological pattern would run on every view change.
+*/
+function readRoutes(routes) {
+	if (!routes || typeof routes !== "object" || Array.isArray(routes)) return;
+	const include = (0, _kubesense_kubesense_browser_core.readStringList)(routes.include);
+	const exclude = (0, _kubesense_kubesense_browser_core.readStringList)(routes.exclude);
+	if (!include && !exclude) return;
+	return {
+		include,
+		exclude
+	};
 }
 function applyProfilingSection(applied, profiling) {
-    if (!profiling) {
-        return;
-    }
-    assign(applied, 'profilingSampleRate', (0, kubesense_browser_core_1.readSampleRate)(profiling, 'sampleRate'));
+	if (!profiling) return;
+	assign(applied, "profilingSampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(profiling, "sampleRate"));
 }
 /**
- * Feature switches are applied last so they always win over the per-section sample rates above.
- * Turning a feature off is expressed through the setting that stops all of its collection.
- */
+* Feature switches are applied last so they always win over the per-section sample rates above.
+* Turning a feature off is expressed through the setting that stops all of its collection.
+*/
 function applyFeatureSwitches(applied, features) {
-    const source = features;
-    if ((0, kubesense_browser_core_1.readBoolean)(source, 'sessionReplay') === false) {
-        applied.sessionReplaySampleRate = 0;
-        applied.startSessionReplayRecordingManually = true;
-        // Drop any route rules too: with replay off they are dead weight, and leaving them behind
-        // would suggest recording still happens somewhere.
-        applied.sessionReplayRoutes = undefined;
-    }
-    if ((0, kubesense_browser_core_1.readBoolean)(source, 'profiling') === false) {
-        applied.profilingSampleRate = 0;
-    }
+	const source = features;
+	if ((0, _kubesense_kubesense_browser_core.readBoolean)(source, "sessionReplay") === false) {
+		applied.sessionReplaySampleRate = 0;
+		applied.startSessionReplayRecordingManually = true;
+		applied.sessionReplayRoutes = void 0;
+	}
+	if ((0, _kubesense_kubesense_browser_core.readBoolean)(source, "profiling") === false) applied.profilingSampleRate = 0;
 }
 /**
- * Assigning only defined values keeps the "absent means keep the local value" guarantee in one
- * place instead of at every call site.
- */
+* Assigning only defined values keeps the "absent means keep the local value" guarantee in one
+* place instead of at every call site.
+*/
 function assign(target, key, value) {
-    if (value !== undefined) {
-        target[key] = value;
-    }
+	if (value !== void 0) target[key] = value;
 }
 /**
- * Refresh the cache for the next page load. Must be called *after* the SDK has started so it
- * never delays initialization.
- */
+* Refresh the cache for the next page load. Must be called *after* the SDK has started so it
+* never delays initialization.
+*/
 function scheduleSdkConfigurationRefresh(initConfiguration) {
-    return (0, kubesense_browser_core_1.refreshSdkConfig)(initConfiguration, initConfiguration.applicationId);
+	return (0, _kubesense_kubesense_browser_core.refreshSdkConfig)(initConfiguration, initConfiguration.applicationId);
 }
+//#endregion
+exports.applyCachedSdkConfiguration = applyCachedSdkConfiguration;
+exports.applySdkConfiguration = applySdkConfiguration;
+exports.scheduleSdkConfigurationRefresh = scheduleSdkConfigurationRefresh;
+
 //# sourceMappingURL=remoteSdkConfiguration.js.map