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

package/cjs/domain/configuration/configuration.js

@@ -1,214 +1,479 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PROPAGATOR_TYPES = void 0;
-exports.validateAndBuildRumConfiguration = validateAndBuildRumConfiguration;
-exports.serializeRumConfiguration = serializeRumConfiguration;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const tracer_1 = require("../tracing/tracer");
-const sessionReplayRoutes_1 = require("./sessionReplayRoutes");
-exports.DEFAULT_PROPAGATOR_TYPES = ['tracecontext', 'kubesense'];
-function validateAndBuildRumConfiguration(initConfiguration, errorStack) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    if (initConfiguration.trackFeatureFlagsForEvents !== undefined &&
-        !Array.isArray(initConfiguration.trackFeatureFlagsForEvents)) {
-        kubesense_browser_core_1.display.warn('trackFeatureFlagsForEvents should be an array');
-    }
-    if (!initConfiguration.applicationId) {
-        kubesense_browser_core_1.display.error('Application ID is not configured, no RUM data will be collected.');
-        return;
-    }
-    if (!(0, kubesense_browser_core_1.isSampleRate)(initConfiguration.sessionReplaySampleRate, 'Session Replay') ||
-        !(0, kubesense_browser_core_1.isSampleRate)(initConfiguration.traceSampleRate, 'Trace')) {
-        return;
-    }
-    if (initConfiguration.excludedActivityUrls !== undefined && !Array.isArray(initConfiguration.excludedActivityUrls)) {
-        kubesense_browser_core_1.display.error('Excluded Activity Urls should be an array');
-        return;
-    }
-    const allowedTracingUrls = validateAndBuildTracingOptions(initConfiguration);
-    if (!allowedTracingUrls) {
-        return;
-    }
-    const baseConfiguration = (0, kubesense_browser_core_1.validateAndBuildConfiguration)(initConfiguration, errorStack);
-    const allowedGraphQlUrls = validateAndBuildGraphQlOptions(initConfiguration);
-    if (!baseConfiguration) {
-        return;
-    }
-    const sessionReplaySampleRate = (_a = initConfiguration.sessionReplaySampleRate) !== null && _a !== void 0 ? _a : 0;
-    return {
-        applicationId: initConfiguration.applicationId,
-        actionNameAttribute: initConfiguration.actionNameAttribute,
-        sessionReplaySampleRate,
-        startSessionReplayRecordingManually: initConfiguration.startSessionReplayRecordingManually !== undefined
-            ? !!initConfiguration.startSessionReplayRecordingManually
-            : sessionReplaySampleRate === 0,
-        sessionReplayRoutes: (0, sessionReplayRoutes_1.validateSessionReplayRoutes)(initConfiguration.sessionReplayRoutes),
-        traceSampleRate: (_b = initConfiguration.traceSampleRate) !== null && _b !== void 0 ? _b : 100,
-        rulePsr: (0, kubesense_browser_core_1.isNumber)(initConfiguration.traceSampleRate) ? initConfiguration.traceSampleRate / 100 : undefined,
-        allowedTracingUrls,
-        excludedActivityUrls: (_c = initConfiguration.excludedActivityUrls) !== null && _c !== void 0 ? _c : [],
-        workerUrl: initConfiguration.workerUrl,
-        compressIntakeRequests: !!initConfiguration.compressIntakeRequests,
-        trackUserInteractions: !!((_d = initConfiguration.trackUserInteractions) !== null && _d !== void 0 ? _d : true),
-        trackViewsManually: !!initConfiguration.trackViewsManually,
-        trackResources: !!((_e = initConfiguration.trackResources) !== null && _e !== void 0 ? _e : true),
-        trackLongTasks: !!((_f = initConfiguration.trackLongTasks) !== null && _f !== void 0 ? _f : true),
-        trackBfcacheViews: !!initConfiguration.trackBfcacheViews,
-        trackEarlyRequests: !!initConfiguration.trackEarlyRequests,
-        subdomain: initConfiguration.subdomain,
-        defaultPrivacyLevel: (0, kubesense_browser_core_1.objectHasValue)(kubesense_browser_core_1.DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)
-            ? initConfiguration.defaultPrivacyLevel
-            : kubesense_browser_core_1.DefaultPrivacyLevel.MASK,
-        enablePrivacyForActionName: !!initConfiguration.enablePrivacyForActionName,
-        traceContextInjection: (0, kubesense_browser_core_1.objectHasValue)(kubesense_browser_core_1.TraceContextInjection, initConfiguration.traceContextInjection)
-            ? initConfiguration.traceContextInjection
-            : kubesense_browser_core_1.TraceContextInjection.SAMPLED,
-        plugins: initConfiguration.plugins || [],
-        trackFeatureFlagsForEvents: initConfiguration.trackFeatureFlagsForEvents || [],
-        profilingSampleRate: (_g = initConfiguration.profilingSampleRate) !== null && _g !== void 0 ? _g : 0,
-        propagateTraceBaggage: !!initConfiguration.propagateTraceBaggage,
-        allowedGraphQlUrls,
-        firstPartyDomains: (_h = initConfiguration.firstPartyDomains) !== null && _h !== void 0 ? _h : [],
-        ...baseConfiguration,
-    };
+const require_remoteConfiguration = require("./remoteConfiguration.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_configuration = require("@kubesense/kubesense-js-core/configuration");
+//#region src/domain/configuration/configuration.ts
+const DEFAULT_PROPAGATOR_TYPES = ["tracecontext", "kubesense"];
+/**
+* Default list of headers collected on resource events when {@link RumInitConfiguration.trackResourceHeaders | trackResourceHeaders}
+* is set to `true`.
+*/
+const DEFAULT_TRACKED_RESOURCE_HEADERS = [
+	"cache-control",
+	"etag",
+	"age",
+	"expires",
+	"content-type",
+	"content-encoding",
+	"vary",
+	"content-length",
+	"server-timing",
+	"x-cache",
+	"cf-cache-status",
+	"x-vercel-cache"
+];
+/**
+* Recording quality presets for canvas capture. See {@link RumInitConfiguration.sessionReplayCanvasRecording}.
+*
+* | Preset   | Frames per second | Longest side | WebP quality |
+* | -------- | ----------------- | ------------ | ------------ |
+* | `low`    | 1                 | 600 px       | 0.3          |
+* | `medium` | 4                 | 1000 px      | 0.5          |
+* | `high`   | 8                 | 1280 px      | 0.75         |
+*
+* @example
+* ```ts
+* kubesenseSdk.init({
+*   // ...
+*   sessionReplayCanvasRecording: {
+*     enable: true,
+*     quality: CanvasRecordingQuality.MEDIUM,
+*   },
+* })
+* ```
+*/
+const CanvasRecordingQuality = {
+	LOW: "low",
+	MEDIUM: "medium",
+	HIGH: "high"
+};
+const CANVAS_RECORDING_QUALITY_PRESETS = {
+	[CanvasRecordingQuality.LOW]: {
+		maxFramesPerSecond: 1,
+		hashingMaxDimension: 50,
+		maxImageDimension: 600,
+		encodeQuality: .3
+	},
+	[CanvasRecordingQuality.MEDIUM]: {
+		maxFramesPerSecond: 4,
+		hashingMaxDimension: 100,
+		maxImageDimension: 1e3,
+		encodeQuality: .5
+	},
+	[CanvasRecordingQuality.HIGH]: {
+		maxFramesPerSecond: 8,
+		hashingMaxDimension: 100,
+		maxImageDimension: 1280,
+		encodeQuality: .75
+	}
+};
+/**
+* Upstream gates canvas recording behind the `session_replay_record_canvas` experimental flag; in
+* this SDK it is a regular option. The preset's values can be overridden one by one, which is how the
+* dashboard's remote configuration tunes them.
+*/
+function resolveCanvasRecordingConfiguration(configuration) {
+	const preset = configuration && CANVAS_RECORDING_QUALITY_PRESETS[configuration.quality];
+	if (!configuration?.enable || !preset) return;
+	return {
+		enable: true,
+		...preset,
+		maxFramesPerSecond: configuration.maxFramesPerSecond ?? preset.maxFramesPerSecond,
+		maxImageDimension: configuration.maxImageDimension ?? preset.maxImageDimension,
+		hashingMaxDimension: configuration.hashingMaxDimension ?? preset.hashingMaxDimension
+	};
 }
+const RUM_SCHEMA = {
+	..._kubesense_kubesense_browser_core.BROWSER_CORE_SCHEMA,
+	applicationId: {
+		type: "string",
+		required: true
+	},
+	actionNameAttribute: { type: "string" },
+	workerUrl: { type: "string" },
+	subdomain: { type: "string" },
+	sessionReplaySampleRate: {
+		type: "percentage",
+		default: 0
+	},
+	traceSampleRate: {
+		type: "percentage",
+		default: 100
+	},
+	profilingSampleRate: {
+		type: "percentage",
+		default: 0
+	},
+	compressIntakeRequests: {
+		type: "boolean",
+		default: false
+	},
+	trackUserInteractions: {
+		type: "boolean",
+		default: true,
+		strict: false
+	},
+	trackResources: {
+		type: "boolean",
+		default: true,
+		strict: false
+	},
+	trackLongTasks: {
+		type: "boolean",
+		default: true,
+		strict: false
+	},
+	trackViewsManually: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	betaEnableViewUpdates: { type: "boolean" },
+	betaTrackWebSockets: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	enablePrivacyForActionName: {
+		type: "boolean",
+		default: true
+	},
+	propagateTraceBaggage: {
+		type: "boolean",
+		default: true
+	},
+	startSessionReplayRecordingManually: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	enableRemoteSdkConfiguration: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	firstPartyDomains: {
+		type: "match-option",
+		multiple: true,
+		default: []
+	},
+	sessionReplayRoutes: {
+		type: "schema",
+		strict: false,
+		schema: {
+			include: {
+				type: "match-option",
+				multiple: true,
+				strict: false
+			},
+			exclude: {
+				type: "match-option",
+				multiple: true,
+				strict: false
+			}
+		}
+	},
+	sessionReplayCanvasRecording: {
+		type: "schema",
+		schema: {
+			enable: {
+				type: "boolean",
+				required: true
+			},
+			quality: {
+				type: "enum",
+				values: CanvasRecordingQuality,
+				default: CanvasRecordingQuality.MEDIUM
+			},
+			maxFramesPerSecond: {
+				type: "number",
+				min: 0,
+				max: 8
+			},
+			maxImageDimension: {
+				type: "number",
+				min: 1,
+				max: 1280
+			},
+			hashingMaxDimension: {
+				type: "number",
+				min: 1,
+				max: 100
+			}
+		}
+	},
+	defaultPrivacyLevel: {
+		type: "enum",
+		values: _kubesense_kubesense_browser_core.DefaultPrivacyLevel,
+		default: _kubesense_kubesense_browser_core.DefaultPrivacyLevel.MASK_USER_INPUT,
+		strict: false
+	},
+	traceContextInjection: {
+		type: "enum",
+		values: _kubesense_kubesense_browser_core.TraceContextInjection,
+		default: _kubesense_kubesense_browser_core.TraceContextInjection.SAMPLED,
+		strict: false
+	},
+	excludedActivityUrls: {
+		type: "match-option",
+		multiple: true,
+		default: []
+	},
+	allowedTracingUrls: {
+		type: "union",
+		multiple: true,
+		strict: false,
+		default: [],
+		variants: [{ type: "match-option" }, {
+			type: "schema",
+			schema: {
+				match: {
+					type: "match-option",
+					required: true
+				},
+				propagatorTypes: {
+					type: "enum",
+					values: [
+						"kubesense",
+						"b3",
+						"b3multi",
+						"tracecontext"
+					],
+					multiple: true,
+					strict: false,
+					default: DEFAULT_PROPAGATOR_TYPES
+				}
+			}
+		}]
+	},
+	plugins: {
+		type: "schema",
+		multiple: true,
+		strict: false,
+		default: [],
+		schema: {
+			name: {
+				type: "string",
+				required: true
+			},
+			getConfigurationTelemetry: {
+				type: "function",
+				strict: false,
+				signature: void 0
+			},
+			onInit: {
+				type: "function",
+				strict: false,
+				signature: void 0
+			},
+			onRumStart: {
+				type: "function",
+				strict: false,
+				signature: void 0
+			}
+		}
+	},
+	trackFeatureFlagsForEvents: {
+		type: "enum",
+		values: [
+			"vital",
+			"action",
+			"long_task",
+			"resource"
+		],
+		multiple: true,
+		strict: false,
+		default: []
+	}
+};
 /**
- * Validates allowedTracingUrls and converts match options to tracing options
- */
-function validateAndBuildTracingOptions(initConfiguration) {
-    if (initConfiguration.allowedTracingUrls === undefined) {
-        return [];
-    }
-    if (!Array.isArray(initConfiguration.allowedTracingUrls)) {
-        kubesense_browser_core_1.display.error('Allowed Tracing URLs should be an array');
-        return;
-    }
-    if (initConfiguration.allowedTracingUrls.length !== 0 && initConfiguration.service === undefined) {
-        kubesense_browser_core_1.display.error('Service needs to be configured when tracing is enabled');
-        return;
-    }
-    // Convert from (MatchOption | TracingOption) to TracingOption, remove unknown properties
-    const tracingOptions = [];
-    initConfiguration.allowedTracingUrls.forEach((option) => {
-        if ((0, kubesense_browser_core_1.isMatchOption)(option)) {
-            tracingOptions.push({ match: option, propagatorTypes: exports.DEFAULT_PROPAGATOR_TYPES });
-        }
-        else if ((0, tracer_1.isTracingOption)(option)) {
-            tracingOptions.push(option);
-        }
-        else {
-            kubesense_browser_core_1.display.warn('Allowed Tracing Urls parameters should be a string, RegExp, function, or an object. Ignoring parameter', option);
-        }
-    });
-    return tracingOptions;
+* Resolves whether partial view updates are enabled. Never enabled when the event bridge is used.
+* Otherwise an explicit `betaEnableViewUpdates` takes precedence, and it defaults to true for CDN
+* users that do not go through a proxy: a proxy may not forward the `view_update` event type yet,
+* and npm users pin an SDK version so they opt in explicitly.
+*
+* The CDN check is temporary, the next step is to default this to true unless `proxy` is set.
+* TODO next major: remove the option.
+*/
+function isViewUpdatesEnabled(explicit, proxy, sdkName) {
+	if ((0, _kubesense_kubesense_browser_core.canUseEventBridge)()) return false;
+	return explicit ?? false;
+}
+function validateAndBuildRumConfiguration(initConfiguration, sdkName) {
+	const config = (0, _kubesense_kubesense_js_core_configuration.validateAndBuildConfiguration)(initConfiguration, RUM_SCHEMA, _kubesense_kubesense_browser_core.display);
+	if (!config) return;
+	const allowedTracingUrls = config.allowedTracingUrls.map(normalizeTracingOption).filter(Boolean);
+	if (allowedTracingUrls.length > 0 && !config.service) {
+		_kubesense_kubesense_browser_core.display.error("Service needs to be configured when tracing is enabled");
+		return;
+	}
+	const sessionReplayCanvasRecording = resolveCanvasRecordingConfiguration(config.sessionReplayCanvasRecording);
+	return {
+		...config,
+		service: config.service || config.applicationId,
+		sessionReplayCanvasRecording,
+		betaEnableViewUpdates: isViewUpdatesEnabled(config.betaEnableViewUpdates, config.proxy, sdkName),
+		allowedTracingUrls,
+		beforeSend: config.beforeSend ? (0, _kubesense_kubesense_browser_core.catchUserErrors)(config.beforeSend, "beforeSend threw an error:") : void 0,
+		rulePsr: (0, _kubesense_kubesense_browser_core.isNumber)(initConfiguration.traceSampleRate) ? initConfiguration.traceSampleRate / 100 : void 0,
+		trackResourceHeaders: validateAndBuildTrackResourceHeaders(initConfiguration),
+		allowedGraphQlUrls: validateAndBuildGraphQlOptions(initConfiguration),
+		remoteConfigurationId: require_remoteConfiguration.getRemoteConfigurationId(initConfiguration)
+	};
 }
 /**
- * Combines the selected tracing propagators from the different options in allowedTracingUrls
- */
+* Combines the selected tracing propagators from the different options in allowedTracingUrls
+*/
 function getSelectedTracingPropagators(configuration) {
-    const usedTracingPropagators = new Set();
-    if ((0, kubesense_browser_core_1.isNonEmptyArray)(configuration.allowedTracingUrls)) {
-        configuration.allowedTracingUrls.forEach((option) => {
-            if ((0, kubesense_browser_core_1.isMatchOption)(option)) {
-                exports.DEFAULT_PROPAGATOR_TYPES.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));
-            }
-            else if ((0, kubesense_browser_core_1.getType)(option) === 'object' && Array.isArray(option.propagatorTypes)) {
-                // Ensure we have an array, as we cannot rely on types yet (configuration is provided by users)
-                option.propagatorTypes.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));
-            }
-        });
-    }
-    return Array.from(usedTracingPropagators);
+	const usedTracingPropagators = /* @__PURE__ */ new Set();
+	if ((0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.allowedTracingUrls)) configuration.allowedTracingUrls.forEach((option) => {
+		normalizeTracingOption(option)?.propagatorTypes.forEach((propagatorType) => usedTracingPropagators.add(propagatorType));
+	});
+	return Array.from(usedTracingPropagators);
+}
+function normalizeTracingOption(option) {
+	if ((0, _kubesense_kubesense_js_core_util.isMatchOption)(option)) return {
+		match: option,
+		propagatorTypes: DEFAULT_PROPAGATOR_TYPES
+	};
+	if ((0, _kubesense_kubesense_js_core_util.isIndexableObject)(option) && (0, _kubesense_kubesense_js_core_util.isMatchOption)(option.match) && (option.propagatorTypes === null || option.propagatorTypes === void 0 || Array.isArray(option.propagatorTypes))) return {
+		match: option.match,
+		propagatorTypes: option.propagatorTypes || DEFAULT_PROPAGATOR_TYPES
+	};
 }
 /**
- * Build GraphQL options from configuration
- */
+* Build GraphQL options from configuration
+*/
 function validateAndBuildGraphQlOptions(initConfiguration) {
-    if (!initConfiguration.allowedGraphQlUrls) {
-        return [];
-    }
-    if (!Array.isArray(initConfiguration.allowedGraphQlUrls)) {
-        kubesense_browser_core_1.display.warn('allowedGraphQlUrls should be an array');
-        return [];
-    }
-    const graphQlOptions = [];
-    initConfiguration.allowedGraphQlUrls.forEach((option) => {
-        if ((0, kubesense_browser_core_1.isMatchOption)(option)) {
-            graphQlOptions.push({ match: option, trackPayload: false, trackResponseErrors: false });
-        }
-        else if (option && typeof option === 'object' && 'match' in option && (0, kubesense_browser_core_1.isMatchOption)(option.match)) {
-            graphQlOptions.push({
-                match: option.match,
-                trackPayload: !!option.trackPayload,
-                trackResponseErrors: !!option.trackResponseErrors,
-            });
-        }
-    });
-    return graphQlOptions;
+	if (!initConfiguration.allowedGraphQlUrls) return [];
+	if (!Array.isArray(initConfiguration.allowedGraphQlUrls)) {
+		_kubesense_kubesense_browser_core.display.warn("allowedGraphQlUrls should be an array");
+		return [];
+	}
+	const graphQlOptions = [];
+	initConfiguration.allowedGraphQlUrls.forEach((option) => {
+		if ((0, _kubesense_kubesense_js_core_util.isMatchOption)(option)) graphQlOptions.push({
+			match: option,
+			trackPayload: false,
+			trackResponseErrors: false
+		});
+		else if ((0, _kubesense_kubesense_js_core_util.isIndexableObject)(option) && (0, _kubesense_kubesense_js_core_util.isMatchOption)(option.match)) graphQlOptions.push({
+			match: option.match,
+			trackPayload: !!option.trackPayload,
+			trackResponseErrors: !!option.trackResponseErrors
+		});
+	});
+	return graphQlOptions;
+}
+const VALID_HEADER_LOCATIONS = [
+	"request",
+	"response",
+	"any"
+];
+function validateAndBuildTrackResourceHeaders(initConfiguration) {
+	const option = initConfiguration.trackResourceHeaders;
+	if (option === void 0 || option === false) return [];
+	if (option === true) return DEFAULT_TRACKED_RESOURCE_HEADERS.map((name) => ({ name }));
+	if (!Array.isArray(option)) {
+		_kubesense_kubesense_browser_core.display.warn("trackResourceHeaders should be true or an array of MatchHeader");
+		return [];
+	}
+	if (option.length === 0) {
+		_kubesense_kubesense_browser_core.display.warn("trackResourceHeaders is an empty array, no headers will be captured");
+		return [];
+	}
+	const result = [];
+	option.forEach((item, index) => {
+		if (!(0, _kubesense_kubesense_js_core_util.isIndexableObject)(item)) {
+			_kubesense_kubesense_browser_core.display.warn(`trackResourceHeaders[${index}] should be a MatchHeader object`);
+			return;
+		}
+		if (item.name !== void 0 && !(0, _kubesense_kubesense_js_core_util.isMatchOption)(item.name)) {
+			_kubesense_kubesense_browser_core.display.warn(`trackResourceHeaders[${index}].name should be a MatchOption`);
+			return;
+		}
+		if (item.url !== void 0 && !(0, _kubesense_kubesense_js_core_util.isMatchOption)(item.url)) {
+			_kubesense_kubesense_browser_core.display.warn(`trackResourceHeaders[${index}].url should be a MatchOption`);
+			return;
+		}
+		if (item.extractor !== void 0 && !(item.extractor instanceof RegExp)) {
+			_kubesense_kubesense_browser_core.display.warn(`trackResourceHeaders[${index}].extractor should be a RegExp`);
+			return;
+		}
+		if (item.location !== void 0 && (typeof item.location !== "string" || !VALID_HEADER_LOCATIONS.includes(item.location))) {
+			_kubesense_kubesense_browser_core.display.warn(`trackResourceHeaders[${index}].location should be 'request', 'response', or 'any'`);
+			return;
+		}
+		const { name, ...rest } = item;
+		result.push({
+			...rest,
+			...name !== void 0 ? { name: typeof name === "string" ? name.toLowerCase() : name } : {}
+		});
+	});
+	return result;
 }
 function hasGraphQlPayloadTracking(allowedGraphQlUrls) {
-    return ((0, kubesense_browser_core_1.isNonEmptyArray)(allowedGraphQlUrls) &&
-        allowedGraphQlUrls.some((option) => {
-            if (typeof option === 'object' && 'trackPayload' in option) {
-                return !!option.trackPayload;
-            }
-            return false;
-        }));
+	return (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(allowedGraphQlUrls) && allowedGraphQlUrls.some((option) => (0, _kubesense_kubesense_js_core_util.isIndexableObject)(option) && option.trackPayload);
 }
 function hasGraphQlResponseErrorsTracking(allowedGraphQlUrls) {
-    return ((0, kubesense_browser_core_1.isNonEmptyArray)(allowedGraphQlUrls) &&
-        allowedGraphQlUrls.some((option) => {
-            if (typeof option === 'object' && 'trackResponseErrors' in option) {
-                return !!option.trackResponseErrors;
-            }
-            return false;
-        }));
+	return (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(allowedGraphQlUrls) && allowedGraphQlUrls.some((option) => (0, _kubesense_kubesense_js_core_util.isIndexableObject)(option) && option.trackResponseErrors);
+}
+function getTrackResourceHeadersTelemetryValue(trackResourceHeaders) {
+	if (trackResourceHeaders === true) return "default_headers";
+	if (Array.isArray(trackResourceHeaders)) return "custom";
 }
-function serializeRumConfiguration(configuration) {
-    var _a;
-    const baseSerializedConfiguration = (0, kubesense_browser_core_1.serializeConfiguration)(configuration);
-    return {
-        session_replay_sample_rate: configuration.sessionReplaySampleRate,
-        start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,
-        trace_sample_rate: configuration.traceSampleRate,
-        trace_context_injection: configuration.traceContextInjection,
-        propagate_trace_baggage: configuration.propagateTraceBaggage,
-        action_name_attribute: configuration.actionNameAttribute,
-        use_allowed_tracing_urls: (0, kubesense_browser_core_1.isNonEmptyArray)(configuration.allowedTracingUrls),
-        use_allowed_graph_ql_urls: (0, kubesense_browser_core_1.isNonEmptyArray)(configuration.allowedGraphQlUrls),
-        use_track_graph_ql_payload: hasGraphQlPayloadTracking(configuration.allowedGraphQlUrls),
-        use_track_graph_ql_response_errors: hasGraphQlResponseErrorsTracking(configuration.allowedGraphQlUrls),
-        selected_tracing_propagators: getSelectedTracingPropagators(configuration),
-        default_privacy_level: configuration.defaultPrivacyLevel,
-        enable_privacy_for_action_name: configuration.enablePrivacyForActionName,
-        use_excluded_activity_urls: (0, kubesense_browser_core_1.isNonEmptyArray)(configuration.excludedActivityUrls),
-        use_worker_url: !!configuration.workerUrl,
-        compress_intake_requests: configuration.compressIntakeRequests,
-        track_views_manually: configuration.trackViewsManually,
-        track_user_interactions: configuration.trackUserInteractions,
-        track_resources: configuration.trackResources,
-        track_long_task: configuration.trackLongTasks,
-        track_bfcache_views: configuration.trackBfcacheViews,
-        track_early_requests: configuration.trackEarlyRequests,
-        plugins: (_a = configuration.plugins) === null || _a === void 0 ? void 0 : _a.map((plugin) => {
-            var _a;
-            return ({
-                name: plugin.name,
-                ...(_a = plugin.getConfigurationTelemetry) === null || _a === void 0 ? void 0 : _a.call(plugin),
-            });
-        }),
-        track_feature_flags_for_events: configuration.trackFeatureFlagsForEvents,
-        remote_configuration_id: configuration.remoteConfigurationId,
-        profiling_sample_rate: configuration.profilingSampleRate,
-        use_remote_configuration_proxy: !!configuration.remoteConfigurationProxy,
-        // Kubesense extensions: whether the dashboard-managed remote document is
-        // in play, and whether replay recording is route-scoped — both needed to
-        // interpret the reported values on the dashboard side.
-        enable_remote_sdk_configuration: !!configuration.enableRemoteSdkConfiguration,
-        use_session_replay_routes: !!configuration.sessionReplayRoutes &&
-            ((0, kubesense_browser_core_1.isNonEmptyArray)(configuration.sessionReplayRoutes.include) ||
-                (0, kubesense_browser_core_1.isNonEmptyArray)(configuration.sessionReplayRoutes.exclude)),
-        ...baseSerializedConfiguration,
-    };
+function serializeRumConfiguration(configuration, sdkName, remoteConfigurationMetadata) {
+	const baseSerializedConfiguration = (0, _kubesense_kubesense_browser_core.serializeConfiguration)(configuration);
+	return {
+		session_replay_sample_rate: configuration.sessionReplaySampleRate,
+		start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,
+		trace_sample_rate: configuration.traceSampleRate,
+		trace_context_injection: configuration.traceContextInjection,
+		propagate_trace_baggage: configuration.propagateTraceBaggage,
+		action_name_attribute: configuration.actionNameAttribute,
+		use_allowed_tracing_urls: (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.allowedTracingUrls),
+		use_allowed_graph_ql_urls: (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.allowedGraphQlUrls),
+		use_track_graph_ql_payload: hasGraphQlPayloadTracking(configuration.allowedGraphQlUrls),
+		use_track_graph_ql_response_errors: hasGraphQlResponseErrorsTracking(configuration.allowedGraphQlUrls),
+		selected_tracing_propagators: getSelectedTracingPropagators(configuration),
+		default_privacy_level: configuration.defaultPrivacyLevel,
+		enable_privacy_for_action_name: configuration.enablePrivacyForActionName,
+		use_excluded_activity_urls: (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.excludedActivityUrls),
+		use_worker_url: !!configuration.workerUrl,
+		compress_intake_requests: configuration.compressIntakeRequests,
+		track_views_manually: configuration.trackViewsManually,
+		track_user_interactions: configuration.trackUserInteractions,
+		track_resources: configuration.trackResources,
+		track_long_task: configuration.trackLongTasks,
+		plugins: configuration.plugins?.map((plugin) => ({
+			name: plugin.name,
+			...plugin.getConfigurationTelemetry?.()
+		})),
+		track_feature_flags_for_events: configuration.trackFeatureFlagsForEvents,
+		remote_configuration_id: require_remoteConfiguration.getRemoteConfigurationId(configuration),
+		remote_configuration: remoteConfigurationMetadata && {
+			last_modified: remoteConfigurationMetadata.lastModified,
+			last_synced: remoteConfigurationMetadata.lastSynced,
+			first_applied: remoteConfigurationMetadata.firstApplied,
+			sync_id: remoteConfigurationMetadata.syncId
+		},
+		profiling_sample_rate: configuration.profilingSampleRate,
+		use_remote_configuration_proxy: !!configuration.remoteConfigurationProxy,
+		enable_remote_sdk_configuration: !!configuration.enableRemoteSdkConfiguration,
+		use_session_replay_routes: !!configuration.sessionReplayRoutes && ((0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.sessionReplayRoutes.include) || (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.sessionReplayRoutes.exclude)),
+		use_first_party_domains: (0, _kubesense_kubesense_browser_core.isNonEmptyArray)(configuration.firstPartyDomains),
+		track_resource_headers: getTrackResourceHeadersTelemetryValue(configuration.trackResourceHeaders),
+		beta_enable_view_updates: isViewUpdatesEnabled(configuration.betaEnableViewUpdates, configuration.proxy, sdkName),
+		beta_track_web_sockets: configuration.betaTrackWebSockets,
+		...baseSerializedConfiguration
+	};
 }
+//#endregion
+exports.CanvasRecordingQuality = CanvasRecordingQuality;
+exports.DEFAULT_PROPAGATOR_TYPES = DEFAULT_PROPAGATOR_TYPES;
+exports.DEFAULT_TRACKED_RESOURCE_HEADERS = DEFAULT_TRACKED_RESOURCE_HEADERS;
+exports.RUM_SCHEMA = RUM_SCHEMA;
+exports.serializeRumConfiguration = serializeRumConfiguration;
+exports.validateAndBuildRumConfiguration = validateAndBuildRumConfiguration;
+
 //# sourceMappingURL=configuration.js.map