@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/esm/domain/telemetry/telemetry.mjs

@@ -0,0 +1,210 @@
+import { BufferedObservable, Observable } from "../../tools/observable.mjs";
+import { display } from "../../tools/display.mjs";
+import { getExperimentalFeatures } from "../../tools/experimentalFeatures.mjs";
+import { noop } from "../../tools/utils/functionUtils.mjs";
+import { computeStackTrace } from "../../tools/stackTrace/computeStackTrace.mjs";
+import { toStackTraceString } from "../../tools/stackTrace/handlingStack.mjs";
+import { jsonStringify } from "../../tools/serialisation/jsonStringify.mjs";
+import { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from "../error/isError.mjs";
+import { buildTags } from "../tags.mjs";
+import { sendToExtension } from "../../tools/sendToExtension.mjs";
+import "../error/error.types.mjs";
+import { getConnectivity } from "../connectivity/connectivity.mjs";
+import { canUseEventBridge, getEventBridge } from "../../transport/eventBridge.mjs";
+import { createBatch } from "../../transport/batch.mjs";
+import { TelemetryType } from "./rawTelemetryEvent.types.mjs";
+import { INTAKE_SITE_STAGING, createEndpointBuilder, createReplicaEndpointBuilder } from "@kubesense/kubesense-js-core/transport";
+import { combine, getDebugMode, globalObject, isWorkerEnvironment } from "@kubesense/kubesense-js-core/util";
+import { startMonitorErrorCollection } from "@kubesense/kubesense-js-core/monitor";
+import { clocksNow } from "@kubesense/kubesense-js-core/time";
+import { DISCARDED } from "@kubesense/kubesense-js-core/assembly";
+import { performDraw } from "@kubesense/kubesense-js-core/sample";
+//#region src/domain/telemetry/telemetry.ts
+const ALLOWED_FRAME_URLS = [
+	"https://rum.kubesense.ai",
+	"https://rum.tyke.ai",
+	"https://d3uc069fcn7uxw.cloudfront.net",
+	"https://d20xtzwzcl0ceb.cloudfront.net",
+	"http://localhost",
+	"<anonymous>"
+];
+let TelemetryService = /* @__PURE__ */ function(TelemetryService) {
+	TelemetryService["LOGS"] = "kubesense-browser-logs-sdk";
+	TelemetryService["RUM"] = "kubesense-browser-rum-sdk";
+	return TelemetryService;
+}({});
+let TelemetryMetrics = /* @__PURE__ */ function(TelemetryMetrics) {
+	TelemetryMetrics["CUSTOMER_DATA_METRIC_NAME"] = "Customer data measures";
+	TelemetryMetrics["REMOTE_CONFIGURATION_METRIC_NAME"] = "remote configuration metrics";
+	TelemetryMetrics["RECORDER_INIT_METRICS_TELEMETRY_NAME"] = "Recorder init metrics";
+	TelemetryMetrics["SEGMENT_METRICS_TELEMETRY_NAME"] = "Segment network request metrics";
+	TelemetryMetrics["SESSION_MANAGER_INIT_METRICS_TELEMETRY_NAME"] = "Session manager init metrics";
+	return TelemetryMetrics;
+}({});
+const METRIC_SAMPLE_RATE = 1;
+const TELEMETRY_EXCLUDED_SITES = [INTAKE_SITE_STAGING];
+const MAX_TELEMETRY_EVENTS_PER_PAGE = 15;
+let telemetryObservable;
+function getTelemetryObservable() {
+	if (!telemetryObservable) telemetryObservable = new BufferedObservable(100);
+	return telemetryObservable;
+}
+function startTelemetry(telemetryService, configuration, hook, sdkName) {
+	const observable = new Observable();
+	const { enabled, metricsEnabled } = startTelemetryCollection(telemetryService, configuration, hook, observable, sdkName);
+	const { stop } = startTelemetryTransport(configuration, observable);
+	return {
+		stop,
+		enabled,
+		metricsEnabled
+	};
+}
+function startTelemetryCollection(telemetryService, configuration, hook, observable, sdkName, metricSampleRate = METRIC_SAMPLE_RATE, maxTelemetryEventsPerPage = MAX_TELEMETRY_EVENTS_PER_PAGE) {
+	const alreadySentEventsByKind = {};
+	const telemetryEnabled = !TELEMETRY_EXCLUDED_SITES.includes(configuration.kubesenseRumEndpoint) && performDraw(configuration.telemetrySampleRate);
+	const telemetryEnabledPerType = {
+		[TelemetryType.LOG]: telemetryEnabled,
+		[TelemetryType.CONFIGURATION]: telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate),
+		[TelemetryType.USAGE]: telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate),
+		metric: telemetryEnabled && performDraw(metricSampleRate)
+	};
+	const runtimeEnvInfo = getRuntimeEnvInfo();
+	const telemetryObservable = getTelemetryObservable();
+	telemetryObservable.subscribe(({ rawEvent, metricName }) => {
+		if (metricName && !telemetryEnabledPerType["metric"] || !telemetryEnabledPerType[rawEvent.type]) return;
+		const kind = metricName || rawEvent.status || rawEvent.type;
+		let alreadySentEvents = alreadySentEventsByKind[kind];
+		if (!alreadySentEvents) alreadySentEvents = alreadySentEventsByKind[kind] = /* @__PURE__ */ new Set();
+		if (alreadySentEvents.size >= maxTelemetryEventsPerPage) return;
+		const stringifiedEvent = jsonStringify(rawEvent);
+		if (alreadySentEvents.has(stringifiedEvent)) return;
+		const defaultTelemetryEventAttributes = hook.trigger({ startTime: clocksNow().relative });
+		if (defaultTelemetryEventAttributes === DISCARDED) return;
+		const event = toTelemetryEvent(defaultTelemetryEventAttributes, telemetryService, rawEvent, runtimeEnvInfo);
+		observable.notify(event);
+		sendToExtension("telemetry", event);
+		alreadySentEvents.add(stringifiedEvent);
+	});
+	telemetryObservable.unbuffer();
+	startMonitorErrorCollection(addTelemetryError);
+	return {
+		enabled: telemetryEnabled,
+		metricsEnabled: telemetryEnabledPerType["metric"]
+	};
+	function toTelemetryEvent(defaultTelemetryEventAttributes, telemetryService, rawEvent, runtimeEnvInfo) {
+		const event = {
+			type: "telemetry",
+			date: clocksNow().timeStamp,
+			service: telemetryService,
+			version: "2.0.0",
+			source: "browser",
+			_kubesense: { format_version: 2 },
+			telemetry: combine(rawEvent, {
+				runtime_env: runtimeEnvInfo,
+				connectivity: getConnectivity(),
+				sdk_setup: "npm",
+				sdk_name: sdkName
+			}),
+			ktags: buildTags(configuration).join(","),
+			experimental_features: Array.from(getExperimentalFeatures())
+		};
+		return combine(event, defaultTelemetryEventAttributes);
+	}
+}
+function startTelemetryTransport(configuration, telemetryObservable) {
+	const cleanupTasks = [];
+	if (canUseEventBridge()) {
+		const bridge = getEventBridge();
+		const telemetrySubscription = telemetryObservable.subscribe((event) => bridge.send("internal_telemetry", event));
+		cleanupTasks.push(telemetrySubscription.unsubscribe);
+	} else {
+		const endpoints = [createEndpointBuilder(configuration, "rum")];
+		const replicaEndpoint = createReplicaEndpointBuilder(configuration, "rum");
+		if (replicaEndpoint && isTelemetryReplicationAllowed(configuration)) endpoints.push(replicaEndpoint);
+		const telemetryBatch = createBatch({
+			endpoints,
+			reportError: noop
+		});
+		cleanupTasks.push(telemetryBatch.stop);
+		const telemetrySubscription = telemetryObservable.subscribe(telemetryBatch.add);
+		cleanupTasks.push(telemetrySubscription.unsubscribe);
+	}
+	return { stop: () => cleanupTasks.forEach((task) => task()) };
+}
+function getRuntimeEnvInfo() {
+	return {
+		is_local_file: globalObject.location?.protocol === "file:",
+		is_worker: isWorkerEnvironment
+	};
+}
+/**
+* Avoid mixing telemetry events from different data centers
+* but keep replicating staging events for reliability
+*/
+function isTelemetryReplicationAllowed(configuration) {
+	return configuration.kubesenseRumEndpoint === INTAKE_SITE_STAGING;
+}
+function addTelemetryDebug(message, context) {
+	if (getDebugMode()) display.debug("[Telemetry]", message, context);
+	getTelemetryObservable().notify({ rawEvent: {
+		type: TelemetryType.LOG,
+		message,
+		status: "debug",
+		...context
+	} });
+}
+function addTelemetryError(e, context) {
+	getTelemetryObservable().notify({ rawEvent: {
+		type: TelemetryType.LOG,
+		status: "error",
+		...formatError(e),
+		...context
+	} });
+}
+function addTelemetryConfiguration(configuration) {
+	getTelemetryObservable().notify({ rawEvent: {
+		type: TelemetryType.CONFIGURATION,
+		configuration
+	} });
+}
+function addTelemetryMetrics(metricName, context) {
+	getTelemetryObservable().notify({
+		rawEvent: {
+			type: TelemetryType.LOG,
+			message: metricName,
+			status: "debug",
+			...context
+		},
+		metricName
+	});
+}
+function addTelemetryUsage(usage) {
+	getTelemetryObservable().notify({ rawEvent: {
+		type: TelemetryType.USAGE,
+		usage
+	} });
+}
+function formatError(e) {
+	if (isError(e)) {
+		const stackTrace = computeStackTrace(e);
+		return {
+			error: {
+				kind: stackTrace.name,
+				stack: toStackTraceString(scrubCustomerFrames(stackTrace))
+			},
+			message: stackTrace.message
+		};
+	}
+	return {
+		error: { stack: NO_ERROR_STACK_PRESENT_MESSAGE },
+		message: `Uncaught ${jsonStringify(e)}`
+	};
+}
+function scrubCustomerFrames(stackTrace) {
+	stackTrace.stack = stackTrace.stack.filter((frame) => !frame.url || ALLOWED_FRAME_URLS.some((allowedFrameUrl) => frame.url.startsWith(allowedFrameUrl)));
+	return stackTrace;
+}
+//#endregion
+export { TelemetryMetrics, TelemetryService, addTelemetryConfiguration, addTelemetryDebug, addTelemetryError, addTelemetryMetrics, addTelemetryUsage, formatError, getTelemetryObservable, scrubCustomerFrames, startTelemetry, startTelemetryCollection, startTelemetryTransport };
+
+//# sourceMappingURL=telemetry.mjs.map

package/esm/domain/telemetry/telemetry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.mjs","names":[],"sources":["../../../src/domain/telemetry/telemetry.ts"],"sourcesContent":["import { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { getDebugMode, combine, globalObject, isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'\nimport type { Hook } from '@kubesense/kubesense-js-core/assembly'\nimport type { RecursivePartial } from '@kubesense/kubesense-js-core/util'\nimport { DISCARDED } from '@kubesense/kubesense-js-core/assembly'\nimport { performDraw } from '@kubesense/kubesense-js-core/sample'\nimport {\n  createEndpointBuilder,\n  createReplicaEndpointBuilder,\n  INTAKE_SITE_STAGING,\n} from '@kubesense/kubesense-js-core/transport'\nimport { startMonitorErrorCollection } from '@kubesense/kubesense-js-core/monitor'\nimport type { Context } from '../../tools/serialisation/context'\nimport { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/isError'\nimport { toStackTraceString } from '../../tools/stackTrace/handlingStack'\nimport { getExperimentalFeatures } from '../../tools/experimentalFeatures'\nimport type { Configuration } from '../configuration'\nimport { buildTags } from '../tags'\nimport { BufferedObservable, Observable } from '../../tools/observable'\nimport { display } from '../../tools/display'\nimport { sendToExtension } from '../../tools/sendToExtension'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport { NonErrorPrefix } from '../error/error.types'\nimport type { StackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { getConnectivity } from '../connectivity'\nimport { canUseEventBridge, getEventBridge, createBatch } from '../../transport'\nimport { noop } from '../../tools/utils/functionUtils'\nimport type { TelemetryEvent } from './telemetryEvent.types'\nimport type {\n  RawTelemetryConfiguration,\n  RawTelemetryEvent,\n  RuntimeEnvInfo,\n  RawTelemetryUsage,\n} from './rawTelemetryEvent.types'\nimport { StatusType, TelemetryType } from './rawTelemetryEvent.types'\n\n// replaced at build time\ndeclare const __BUILD_ENV__SDK_VERSION__: string\ndeclare const __BUILD_ENV__SDK_SETUP__: string\n\nconst ALLOWED_FRAME_URLS = [\n  'https://rum.kubesense.ai',\n  'https://rum.tyke.ai',\n  'https://d3uc069fcn7uxw.cloudfront.net',\n  'https://d20xtzwzcl0ceb.cloudfront.net',\n  'http://localhost',\n  '<anonymous>',\n]\n\nexport const enum TelemetryService {\n  LOGS = 'kubesense-browser-logs-sdk',\n  RUM = 'kubesense-browser-rum-sdk',\n}\n\nexport interface Telemetry {\n  stop: () => void\n  enabled: boolean\n  metricsEnabled: boolean\n}\n\nexport const enum TelemetryMetrics {\n  CUSTOMER_DATA_METRIC_NAME = 'Customer data measures',\n  REMOTE_CONFIGURATION_METRIC_NAME = 'remote configuration metrics',\n  RECORDER_INIT_METRICS_TELEMETRY_NAME = 'Recorder init metrics',\n  SEGMENT_METRICS_TELEMETRY_NAME = 'Segment network request metrics',\n  SESSION_MANAGER_INIT_METRICS_TELEMETRY_NAME = 'Session manager init metrics',\n}\n\nconst METRIC_SAMPLE_RATE = 1\n\nconst TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_STAGING]\nconst MAX_TELEMETRY_EVENTS_PER_PAGE = 15\n\nlet telemetryObservable: BufferedObservable<{ rawEvent: RawTelemetryEvent; metricName?: string }> | undefined\n\nexport function getTelemetryObservable() {\n  if (!telemetryObservable) {\n    telemetryObservable = new BufferedObservable(100)\n  }\n  return telemetryObservable\n}\n\nexport function startTelemetry(\n  telemetryService: TelemetryService,\n  configuration: Configuration,\n  hook: Hook<any, any>,\n  sdkName?: string\n): Telemetry {\n  const observable = new Observable<TelemetryEvent & Context>()\n  const { enabled, metricsEnabled } = startTelemetryCollection(\n    telemetryService,\n    configuration,\n    hook,\n    observable,\n    sdkName\n  )\n  const { stop } = startTelemetryTransport(configuration, observable)\n  return {\n    stop,\n    enabled,\n    metricsEnabled,\n  }\n}\n\nexport function startTelemetryCollection(\n  telemetryService: TelemetryService,\n  configuration: Configuration,\n  hook: Hook<any, any>,\n  observable: Observable<TelemetryEvent & Context>,\n  sdkName?: string,\n  metricSampleRate = METRIC_SAMPLE_RATE,\n  maxTelemetryEventsPerPage = MAX_TELEMETRY_EVENTS_PER_PAGE\n) {\n  const alreadySentEventsByKind: Record<string, Set<string>> = {}\n\n  const telemetryEnabled =\n    !TELEMETRY_EXCLUDED_SITES.includes(configuration.kubesenseRumEndpoint) &&\n    performDraw(configuration.telemetrySampleRate)\n\n  const telemetryEnabledPerType = {\n    [TelemetryType.LOG]: telemetryEnabled,\n    [TelemetryType.CONFIGURATION]: telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate),\n    [TelemetryType.USAGE]: telemetryEnabled && performDraw(configuration.telemetryUsageSampleRate),\n    // not an actual \"type\" but using a single draw for all metrics\n    metric: telemetryEnabled && performDraw(metricSampleRate),\n  }\n\n  const runtimeEnvInfo = getRuntimeEnvInfo()\n  const telemetryObservable = getTelemetryObservable()\n  telemetryObservable.subscribe(({ rawEvent, metricName }) => {\n    if ((metricName && !telemetryEnabledPerType['metric']) || !telemetryEnabledPerType[rawEvent.type!]) {\n      return\n    }\n\n    const kind = metricName || (rawEvent.status as string | undefined) || rawEvent.type!\n    let alreadySentEvents = alreadySentEventsByKind[kind]\n    if (!alreadySentEvents) {\n      alreadySentEvents = alreadySentEventsByKind[kind] = new Set()\n    }\n\n    if (alreadySentEvents.size >= maxTelemetryEventsPerPage) {\n      return\n    }\n\n    const stringifiedEvent = jsonStringify(rawEvent)!\n    if (alreadySentEvents.has(stringifiedEvent)) {\n      return\n    }\n\n    const defaultTelemetryEventAttributes = hook.trigger({\n      startTime: clocksNow().relative,\n    })\n\n    if (defaultTelemetryEventAttributes === DISCARDED) {\n      return\n    }\n    const event = toTelemetryEvent(\n      defaultTelemetryEventAttributes as RecursivePartial<TelemetryEvent>,\n      telemetryService,\n      rawEvent,\n      runtimeEnvInfo\n    )\n    observable.notify(event)\n    sendToExtension('telemetry', event)\n    alreadySentEvents.add(stringifiedEvent)\n  })\n  telemetryObservable.unbuffer()\n\n  startMonitorErrorCollection(addTelemetryError)\n\n  return {\n    enabled: telemetryEnabled,\n    metricsEnabled: telemetryEnabledPerType['metric'],\n  }\n\n  function toTelemetryEvent(\n    defaultTelemetryEventAttributes: RecursivePartial<TelemetryEvent>,\n    telemetryService: TelemetryService,\n    rawEvent: RawTelemetryEvent,\n    runtimeEnvInfo: RuntimeEnvInfo\n  ): TelemetryEvent & Context {\n    const clockNow = clocksNow()\n\n    const event = {\n      type: 'telemetry' as const,\n      date: clockNow.timeStamp,\n      service: telemetryService,\n      version: __BUILD_ENV__SDK_VERSION__,\n      source: 'browser' as const,\n      _kubesense: {\n        format_version: 2 as const,\n      },\n      telemetry: combine(rawEvent, {\n        runtime_env: runtimeEnvInfo,\n        connectivity: getConnectivity(),\n        sdk_setup: __BUILD_ENV__SDK_SETUP__,\n        sdk_name: sdkName,\n      }) as TelemetryEvent['telemetry'],\n      ktags: buildTags(configuration).join(','),\n      experimental_features: Array.from(getExperimentalFeatures()),\n    }\n\n    return combine(event, defaultTelemetryEventAttributes) as TelemetryEvent & Context\n  }\n}\n\nexport function startTelemetryTransport(\n  configuration: Configuration,\n  telemetryObservable: Observable<TelemetryEvent & Context>\n) {\n  const cleanupTasks: Array<() => void> = []\n  if (canUseEventBridge()) {\n    const bridge = getEventBridge<'internal_telemetry', TelemetryEvent>()!\n    const telemetrySubscription = telemetryObservable.subscribe((event) => bridge.send('internal_telemetry', event))\n    cleanupTasks.push(telemetrySubscription.unsubscribe)\n  } else {\n    const endpoints = [createEndpointBuilder(configuration, 'rum')]\n    const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'rum')\n    if (replicaEndpoint && isTelemetryReplicationAllowed(configuration)) {\n      endpoints.push(replicaEndpoint)\n    }\n    const telemetryBatch = createBatch({\n      endpoints,\n      // Ignore transport errors for telemetry\n      reportError: noop,\n    })\n    cleanupTasks.push(telemetryBatch.stop)\n    const telemetrySubscription = telemetryObservable.subscribe(telemetryBatch.add)\n    cleanupTasks.push(telemetrySubscription.unsubscribe)\n  }\n\n  return {\n    stop: () => cleanupTasks.forEach((task) => task()),\n  }\n}\n\nfunction getRuntimeEnvInfo(): RuntimeEnvInfo {\n  return {\n    is_local_file: globalObject.location?.protocol === 'file:',\n    is_worker: isWorkerEnvironment,\n  }\n}\n\nexport function resetTelemetry() {\n  telemetryObservable = undefined\n}\n\n/**\n * Avoid mixing telemetry events from different data centers\n * but keep replicating staging events for reliability\n */\nfunction isTelemetryReplicationAllowed(configuration: Configuration) {\n  return configuration.kubesenseRumEndpoint === INTAKE_SITE_STAGING\n}\n\nexport function addTelemetryDebug(message: string, context?: Context) {\n  if (getDebugMode()) {\n    display.debug('[Telemetry]', message, context)\n  }\n  getTelemetryObservable().notify({\n    rawEvent: {\n      type: TelemetryType.LOG,\n      message,\n      status: StatusType.debug,\n      ...context,\n    },\n  })\n}\n\nexport function addTelemetryError(e: unknown, context?: Context) {\n  getTelemetryObservable().notify({\n    rawEvent: {\n      type: TelemetryType.LOG,\n      status: StatusType.error,\n      ...formatError(e),\n      ...context,\n    },\n  })\n}\n\nexport function addTelemetryConfiguration(configuration: RawTelemetryConfiguration) {\n  getTelemetryObservable().notify({\n    rawEvent: {\n      type: TelemetryType.CONFIGURATION,\n      configuration,\n    },\n  })\n}\n\nexport function addTelemetryMetrics(metricName: TelemetryMetrics, context?: Context) {\n  getTelemetryObservable().notify({\n    rawEvent: {\n      type: TelemetryType.LOG,\n      message: metricName,\n      status: StatusType.debug,\n      ...context,\n    },\n    metricName,\n  })\n}\n\nexport function addTelemetryUsage(usage: RawTelemetryUsage) {\n  getTelemetryObservable().notify({\n    rawEvent: {\n      type: TelemetryType.USAGE,\n      usage,\n    },\n  })\n}\n\nexport function formatError(e: unknown) {\n  if (isError(e)) {\n    const stackTrace = computeStackTrace(e)\n    return {\n      error: {\n        kind: stackTrace.name,\n        stack: toStackTraceString(scrubCustomerFrames(stackTrace)),\n      },\n      message: stackTrace.message!,\n    }\n  }\n  return {\n    error: {\n      stack: NO_ERROR_STACK_PRESENT_MESSAGE,\n    },\n    message: `${NonErrorPrefix.UNCAUGHT} ${jsonStringify(e)!}`,\n  }\n}\n\nexport function scrubCustomerFrames(stackTrace: StackTrace) {\n  stackTrace.stack = stackTrace.stack.filter(\n    (frame) => !frame.url || ALLOWED_FRAME_URLS.some((allowedFrameUrl) => frame.url!.startsWith(allowedFrameUrl))\n  )\n  return stackTrace\n}\n"],"mappings":"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"}

package/esm/domain/trackingConsent.mjs

@@ -0,0 +1,38 @@
+import { Observable } from "../tools/observable.mjs";
+//#region src/domain/trackingConsent.ts
+const TrackingConsent = {
+	GRANTED: "granted",
+	NOT_GRANTED: "not-granted"
+};
+function createTrackingConsentState(currentConsent) {
+	const observable = new Observable();
+	function isGranted() {
+		return currentConsent === TrackingConsent.GRANTED;
+	}
+	return {
+		tryToInit(trackingConsent) {
+			if (!currentConsent) currentConsent = trackingConsent;
+		},
+		onGrantedOnce(fn) {
+			if (isGranted()) fn();
+			else {
+				const subscription = observable.subscribe(() => {
+					if (isGranted()) {
+						fn();
+						subscription.unsubscribe();
+					}
+				});
+			}
+		},
+		update(trackingConsent) {
+			currentConsent = trackingConsent;
+			observable.notify();
+		},
+		isGranted,
+		observable
+	};
+}
+//#endregion
+export { TrackingConsent, createTrackingConsentState };
+
+//# sourceMappingURL=trackingConsent.mjs.map

package/esm/domain/trackingConsent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackingConsent.mjs","names":[],"sources":["../../src/domain/trackingConsent.ts"],"sourcesContent":["import { Observable } from '../tools/observable'\n\nexport const TrackingConsent = {\n  GRANTED: 'granted',\n  NOT_GRANTED: 'not-granted',\n} as const\nexport type TrackingConsent = (typeof TrackingConsent)[keyof typeof TrackingConsent]\n\nexport interface TrackingConsentState {\n  tryToInit: (trackingConsent: TrackingConsent) => void\n  update: (trackingConsent: TrackingConsent) => void\n  isGranted: () => boolean\n  observable: Observable<void>\n  onGrantedOnce: (callback: () => void) => void\n}\n\nexport function createTrackingConsentState(currentConsent?: TrackingConsent): TrackingConsentState {\n  const observable = new Observable<void>()\n\n  function isGranted() {\n    return currentConsent === TrackingConsent.GRANTED\n  }\n\n  return {\n    tryToInit(trackingConsent: TrackingConsent) {\n      if (!currentConsent) {\n        currentConsent = trackingConsent\n      }\n    },\n    onGrantedOnce(fn) {\n      if (isGranted()) {\n        fn()\n      } else {\n        const subscription = observable.subscribe(() => {\n          if (isGranted()) {\n            fn()\n            subscription.unsubscribe()\n          }\n        })\n      }\n    },\n    update(trackingConsent: TrackingConsent) {\n      currentConsent = trackingConsent\n      observable.notify()\n    },\n    isGranted,\n    observable,\n  }\n}\n"],"mappings":";;AAEA,MAAa,kBAAkB;CAC7B,SAAS;CACT,aAAa;AACf;AAWA,SAAgB,2BAA2B,gBAAwD;CACjG,MAAM,aAAa,IAAI,WAAiB;CAExC,SAAS,YAAY;EACnB,OAAO,mBAAmB,gBAAgB;CAC5C;CAEA,OAAO;EACL,UAAU,iBAAkC;GAC1C,IAAI,CAAC,gBACH,iBAAiB;EAErB;EACA,cAAc,IAAI;GAChB,IAAI,UAAU,GACZ,GAAG;QACE;IACL,MAAM,eAAe,WAAW,gBAAgB;KAC9C,IAAI,UAAU,GAAG;MACf,GAAG;MACH,aAAa,YAAY;KAC3B;IACF,CAAC;GACH;EACF;EACA,OAAO,iBAAkC;GACvC,iBAAiB;GACjB,WAAW,OAAO;EACpB;EACA;EACA;CACF;AACF"}

package/esm/domain/userAgentData/userAgentData.mjs

@@ -0,0 +1,77 @@
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/userAgentData/userAgentData.ts
+const BRAND_PRIORITY = {
+	"Microsoft Edge": 1,
+	"Google Chrome": 2,
+	Chromium: 3,
+	Opera: 4,
+	Brave: 5
+};
+function pickBrand(brands) {
+	if (!brands || brands.length === 0) return;
+	let best;
+	let bestPriority = Number.MAX_SAFE_INTEGER;
+	for (const entry of brands) {
+		if (!entry.brand || entry.brand.indexOf("Not") === 0) continue;
+		const priority = BRAND_PRIORITY[entry.brand] ?? 99;
+		if (priority < bestPriority) {
+			best = entry;
+			bestPriority = priority;
+		}
+	}
+	return best ?? brands.find((b) => b.brand && b.brand.indexOf("Not") !== 0);
+}
+function majorVersion(version) {
+	const dot = version.indexOf(".");
+	return dot >= 0 ? version.slice(0, dot) : version;
+}
+function getUAData() {
+	return globalObject.navigator?.userAgentData;
+}
+function getSyncUserAgentContext() {
+	const uaData = getUAData();
+	if (!uaData) return;
+	const brand = pickBrand(uaData.brands);
+	if (!brand) return;
+	return { browser: {
+		name: brand.brand,
+		version: brand.version
+	} };
+}
+function resolveHighEntropyUserAgentContext() {
+	const uaData = getUAData();
+	if (!uaData || typeof uaData.getHighEntropyValues !== "function") return Promise.resolve(void 0);
+	return uaData.getHighEntropyValues([
+		"fullVersionList",
+		"platformVersion",
+		"model",
+		"architecture",
+		"bitness"
+	]).then((values) => {
+		const ctx = {};
+		const fullBrand = pickBrand(values.fullVersionList) ?? pickBrand(uaData.brands);
+		if (fullBrand) ctx.browser = {
+			name: fullBrand.brand,
+			version: fullBrand.version
+		};
+		const platformVersion = values.platformVersion ?? "";
+		const platformName = uaData.platform || values.platform || "";
+		if (platformVersion && platformName) ctx.os = {
+			name: platformName,
+			version: platformVersion,
+			version_major: majorVersion(platformVersion)
+		};
+		const model = values.model || "";
+		const architecture = values.architecture || "";
+		if (model || architecture || uaData.mobile) ctx.device = {
+			type: uaData.mobile ? "mobile" : "desktop",
+			model: model || void 0,
+			architecture: architecture || void 0
+		};
+		return ctx;
+	}).catch(() => void 0);
+}
+//#endregion
+export { getSyncUserAgentContext, resolveHighEntropyUserAgentContext };
+
+//# sourceMappingURL=userAgentData.mjs.map

package/esm/domain/userAgentData/userAgentData.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"userAgentData.mjs","names":[],"sources":["../../../src/domain/userAgentData/userAgentData.ts"],"sourcesContent":["import { globalObject } from '@kubesense/kubesense-js-core/util'\n\nexport interface UserAgentBrowser {\n  name: string\n  version: string\n}\n\nexport interface UserAgentOS {\n  name: string\n  version: string\n  version_major: string\n}\n\nexport interface UserAgentDevice {\n  type?: 'mobile' | 'desktop' | 'tablet' | 'tv' | 'gaming_console' | 'bot' | 'other'\n  model?: string\n  brand?: string\n  architecture?: string\n}\n\nexport interface UserAgentContext {\n  browser?: UserAgentBrowser\n  os?: UserAgentOS\n  device?: UserAgentDevice\n}\n\ninterface UADataBrand {\n  brand: string\n  version: string\n}\n\ninterface NavigatorUAData {\n  readonly brands: UADataBrand[]\n  readonly mobile: boolean\n  readonly platform: string\n  getHighEntropyValues(hints: string[]): Promise<{\n    architecture?: string\n    bitness?: string\n    brands?: UADataBrand[]\n    fullVersionList?: UADataBrand[]\n    mobile?: boolean\n    model?: string\n    platform?: string\n    platformVersion?: string\n    wow64?: boolean\n  }>\n}\n\ninterface NavigatorWithUAData extends Navigator {\n  userAgentData?: NavigatorUAData\n}\n\n// Chromium ships its brand list with intentionally-shuffled \"Not-A.Brand\" /\n// \"Not(A:Brand\" entries to discourage UA sniffing. Pick the most-specific real\n// brand: Edge > Chrome > Chromium > anything else.\nconst BRAND_PRIORITY: Record<string, number> = {\n  'Microsoft Edge': 1,\n  'Google Chrome': 2,\n  Chromium: 3,\n  Opera: 4,\n  Brave: 5,\n}\n\nfunction pickBrand(brands: UADataBrand[] | undefined): UADataBrand | undefined {\n  if (!brands || brands.length === 0) {\n    return undefined\n  }\n  let best: UADataBrand | undefined\n  let bestPriority = Number.MAX_SAFE_INTEGER\n  for (const entry of brands) {\n    if (!entry.brand || entry.brand.indexOf('Not') === 0) {\n      continue\n    }\n    const priority = BRAND_PRIORITY[entry.brand] ?? 99\n    if (priority < bestPriority) {\n      best = entry\n      bestPriority = priority\n    }\n  }\n  return best ?? brands.find((b) => b.brand && b.brand.indexOf('Not') !== 0)\n}\n\nfunction majorVersion(version: string): string {\n  const dot = version.indexOf('.')\n  return dot >= 0 ? version.slice(0, dot) : version\n}\n\nfunction getUAData(): NavigatorUAData | undefined {\n  const nav = globalObject.navigator as NavigatorWithUAData | undefined\n  return nav?.userAgentData\n}\n\n// Sync values available immediately on first paint: brand + major version\n// from low-entropy hints. We deliberately do NOT emit os/device here — only\n// the platform *name* is available synchronously, not the version, and the\n// server's setOperatingSystem/setDevice overwrites unconditionally, so\n// shipping empty version strings would clobber the server-side UA fallback.\n// Browser brand + major version, by contrast, is reliable from sync hints.\n// Returns undefined on non-Chromium so the server's UA parser handles\n// Safari/Firefox — their classic UA isn't frozen.\nexport function getSyncUserAgentContext(): UserAgentContext | undefined {\n  const uaData = getUAData()\n  if (!uaData) {\n    return undefined\n  }\n  const brand = pickBrand(uaData.brands)\n  if (!brand) {\n    return undefined\n  }\n  return { browser: { name: brand.brand, version: brand.version } }\n}\n\n// Async high-entropy values: full browser version, real OS version (recovers\n// the value the classic UA freezes — macOS 14.x.y instead of 10.15.7, Windows\n// 13.x build instead of 10.0), model on mobile, CPU architecture.\nexport function resolveHighEntropyUserAgentContext(): Promise<UserAgentContext | undefined> {\n  const uaData = getUAData()\n  if (!uaData || typeof uaData.getHighEntropyValues !== 'function') {\n    return Promise.resolve(undefined)\n  }\n\n  return uaData\n    .getHighEntropyValues(['fullVersionList', 'platformVersion', 'model', 'architecture', 'bitness'])\n    .then((values) => {\n      const ctx: UserAgentContext = {}\n\n      const fullBrand = pickBrand(values.fullVersionList) ?? pickBrand(uaData.brands)\n      if (fullBrand) {\n        ctx.browser = { name: fullBrand.brand, version: fullBrand.version }\n      }\n\n      // Only emit os when we have a real version — empty strings would\n      // overwrite the server-side UA fallback (setOperatingSystem is an\n      // unconditional assign). platformVersion can be blank when the page\n      // sets Permissions-Policy: ch-ua-platform-version=() or in some\n      // privacy-hardened browsers (Brave strict mode).\n      const platformVersion = values.platformVersion ?? ''\n      const platformName = uaData.platform || values.platform || ''\n      if (platformVersion && platformName) {\n        ctx.os = {\n          name: platformName,\n          version: platformVersion,\n          version_major: majorVersion(platformVersion),\n        }\n      }\n\n      // Same reasoning for device — only emit if we have a meaningful model\n      // or architecture; otherwise the server-side device_name/brand\n      // fallback (\"Mac\", \"Apple\", \"Windows\", …) survives.\n      const model = values.model || ''\n      const architecture = values.architecture || ''\n      if (model || architecture || uaData.mobile) {\n        ctx.device = {\n          type: uaData.mobile ? 'mobile' : 'desktop',\n          model: model || undefined,\n          architecture: architecture || undefined,\n        }\n      }\n\n      return ctx\n    })\n    .catch(() => undefined)\n}\n"],"mappings":";;AAuDA,MAAM,iBAAyC;CAC7C,kBAAkB;CAClB,iBAAiB;CACjB,UAAU;CACV,OAAO;CACP,OAAO;AACT;AAEA,SAAS,UAAU,QAA4D;CAC7E,IAAI,CAAC,UAAU,OAAO,WAAW,GAC/B;CAEF,IAAI;CACJ,IAAI,eAAe,OAAO;CAC1B,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,CAAC,MAAM,SAAS,MAAM,MAAM,QAAQ,KAAK,MAAM,GACjD;EAEF,MAAM,WAAW,eAAe,MAAM,UAAU;EAChD,IAAI,WAAW,cAAc;GAC3B,OAAO;GACP,eAAe;EACjB;CACF;CACA,OAAO,QAAQ,OAAO,MAAM,MAAM,EAAE,SAAS,EAAE,MAAM,QAAQ,KAAK,MAAM,CAAC;AAC3E;AAEA,SAAS,aAAa,SAAyB;CAC7C,MAAM,MAAM,QAAQ,QAAQ,GAAG;CAC/B,OAAO,OAAO,IAAI,QAAQ,MAAM,GAAG,GAAG,IAAI;AAC5C;AAEA,SAAS,YAAyC;CAEhD,OADY,aAAa,WACb;AACd;AAUA,SAAgB,0BAAwD;CACtE,MAAM,SAAS,UAAU;CACzB,IAAI,CAAC,QACH;CAEF,MAAM,QAAQ,UAAU,OAAO,MAAM;CACrC,IAAI,CAAC,OACH;CAEF,OAAO,EAAE,SAAS;EAAE,MAAM,MAAM;EAAO,SAAS,MAAM;CAAQ,EAAE;AAClE;AAKA,SAAgB,qCAA4E;CAC1F,MAAM,SAAS,UAAU;CACzB,IAAI,CAAC,UAAU,OAAO,OAAO,yBAAyB,YACpD,OAAO,QAAQ,QAAQ,KAAA,CAAS;CAGlC,OAAO,OACJ,qBAAqB;EAAC;EAAmB;EAAmB;EAAS;EAAgB;CAAS,CAAC,CAAC,CAChG,MAAM,WAAW;EAChB,MAAM,MAAwB,CAAC;EAE/B,MAAM,YAAY,UAAU,OAAO,eAAe,KAAK,UAAU,OAAO,MAAM;EAC9E,IAAI,WACF,IAAI,UAAU;GAAE,MAAM,UAAU;GAAO,SAAS,UAAU;EAAQ;EAQpE,MAAM,kBAAkB,OAAO,mBAAmB;EAClD,MAAM,eAAe,OAAO,YAAY,OAAO,YAAY;EAC3D,IAAI,mBAAmB,cACrB,IAAI,KAAK;GACP,MAAM;GACN,SAAS;GACT,eAAe,aAAa,eAAe;EAC7C;EAMF,MAAM,QAAQ,OAAO,SAAS;EAC9B,MAAM,eAAe,OAAO,gBAAgB;EAC5C,IAAI,SAAS,gBAAgB,OAAO,QAClC,IAAI,SAAS;GACX,MAAM,OAAO,SAAS,WAAW;GACjC,OAAO,SAAS,KAAA;GAChB,cAAc,gBAAgB,KAAA;EAChC;EAGF,OAAO;CACT,CAAC,CAAC,CACD,YAAY,KAAA,CAAS;AAC1B"}

package/esm/index.mjs

@@ -0,0 +1,85 @@
+import { BufferedObservable, Observable } from "./tools/observable.mjs";
+import { TrackingConsent, createTrackingConsentState } from "./domain/trackingConsent.mjs";
+import { BROWSER_CORE_SCHEMA, DefaultPrivacyLevel, TraceContextInjection, serializeConfiguration } from "./domain/configuration/configuration.mjs";
+import { findAllCommaSeparatedValues, findCommaSeparatedValue, findCommaSeparatedValues, generateUUID, safeTruncate, toIntegrations, toMajorVersionIntegration } from "./tools/utils/stringUtils.mjs";
+import { getZoneJsOriginalValue } from "./tools/getZoneJsOriginalValue.mjs";
+import { fetch } from "./browser/fetch.mjs";
+import { DOCS_TROUBLESHOOTING, display } from "./tools/display.mjs";
+import { SDK_CONFIG_CACHE_KEY, SDK_CONFIG_PATH, buildSdkConfigEndpoint, clearCachedSdkConfig, getCachedSdkConfig, parseSdkConfig, readBoolean, readEnum, readNumberInRange, readSampleRate, readString, readStringList, refreshSdkConfig, setCachedSdkConfig } from "./domain/configuration/remoteSdkConfig.mjs";
+import { deleteCookie, getCookie, getInitCookie, resetInitCookies, setCookie } from "./browser/cookie.mjs";
+import { matchList } from "./tools/matchOption.mjs";
+import { mockable } from "./tools/mockable.mjs";
+import { isAllowedTrackingOrigins } from "./domain/allowedTrackingOrigins.mjs";
+import { getConstructorName, isEmptyObject, mapValues, objectHasValue, shallowClone, tryJsonParse } from "./tools/utils/objectUtils.mjs";
+import { ExperimentalFeature, addExperimentalFeatures, getExperimentalFeatures, initFeatureFlags, isExperimentalFeatureEnabled } from "./tools/experimentalFeatures.mjs";
+import { clearInterval, clearTimeout, setInterval, setTimeout } from "./tools/timer.mjs";
+import { noop, throttle } from "./tools/utils/functionUtils.mjs";
+import { computeStackTrace } from "./tools/stackTrace/computeStackTrace.mjs";
+import { createHandlingStack, formatErrorMessage, toStackTraceString } from "./tools/stackTrace/handlingStack.mjs";
+import { instrumentConstructor, instrumentMethod, instrumentSetter } from "./tools/instrumentMethod.mjs";
+import { DOM_EVENT, addEventListener, addEventListeners, isEventSupported, resetAllowUntrustedEvents, setAllowUntrustedEvents } from "./browser/addEventListener.mjs";
+import { ONE_KIBI_BYTE, ONE_MEBI_BYTE, computeBytesCount, concatBuffers } from "./tools/utils/byteUtils.mjs";
+import { detachToJsonMethod, jsonStringify } from "./tools/serialisation/jsonStringify.mjs";
+import { SANITIZE_DEFAULT_MAX_CHARACTER_COUNT, sanitize } from "./tools/serialisation/sanitize.mjs";
+import { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from "./domain/error/isError.mjs";
+import { TAG_SIZE_LIMIT, buildTag, buildTags, sanitizeTag } from "./domain/tags.mjs";
+import { sendToExtension } from "./tools/sendToExtension.mjs";
+import { ErrorHandling, ErrorSource, NonErrorPrefix } from "./domain/error/error.types.mjs";
+import { getConnectivity } from "./domain/connectivity/connectivity.mjs";
+import { isServerError, tryToClone } from "./tools/utils/responseUtils.mjs";
+import { createHttpRequest } from "./transport/httpRequest.mjs";
+import { BridgeCapability, bridgeSupports, canUseEventBridge, getEventBridge } from "./transport/eventBridge.mjs";
+import { findLast, objectEntries, objectValues } from "./tools/utils/polyfills.mjs";
+import { PageExitReason, createPageMayExitObservable, isPageExitReason } from "./browser/pageMayExitObservable.mjs";
+import { createIdentityEncoder } from "./tools/encoder.mjs";
+import { FLUSH_DURATION_LIMIT, createFlushController } from "./transport/flushController.mjs";
+import { createBatch } from "./transport/batch.mjs";
+import { TelemetryMetrics, TelemetryService, addTelemetryConfiguration, addTelemetryDebug, addTelemetryError, addTelemetryMetrics, addTelemetryUsage, startTelemetry } from "./domain/telemetry/telemetry.mjs";
+import { buildDebugIdByUrl, getSourceCodeContext } from "./domain/sourceCodeContext.mjs";
+import { DEFAULT_ERROR_TYPE, computeRawError, getFileFromStackTraceString, getStackTraceUrls } from "./domain/error/error.mjs";
+import { trackRuntimeError } from "./domain/error/trackRuntimeError.mjs";
+import { catchUserErrors } from "./tools/catchUserErrors.mjs";
+import { defineGlobal, makePublicApi } from "./boot/init.mjs";
+import { displayAlreadyInitializedError } from "./boot/displayAlreadyInitializedError.mjs";
+import { RawReportType, initReportObservable } from "./domain/report/reportObservable.mjs";
+import { isNonEmptyArray, mergeArrays, removeDuplicates, removeItem } from "./tools/utils/arrayUtils.mjs";
+import { CLEAR_OLD_VALUES_INTERVAL, createValueHistory } from "./tools/valueHistory.mjs";
+import { correctedChildSampleRate, isSampled, resetSampleDecisionCache, sampleUsingKnuthFactor } from "./domain/sampler.mjs";
+import { SESSION_EXPIRATION_DELAY, SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY, SessionPersistence } from "./domain/session/sessionConstants.mjs";
+import { isCookieStoreSupported } from "./browser/cookieAccess.mjs";
+import { SESSION_STORE_KEY } from "./domain/session/storeStrategies/sessionStoreStrategy.mjs";
+import { MEMORY_SESSION_STORE_KEY } from "./domain/session/storeStrategies/sessionInMemory.mjs";
+import { getSessionEndClocks, startSessionManager, startSessionManagerStub, stopSessionManager } from "./domain/session/sessionManager.mjs";
+import { AbstractLifeCycle } from "./tools/abstractLifeCycle.mjs";
+import { createEventRateLimiter } from "./domain/eventRateLimiter/createEventRateLimiter.mjs";
+import { Browser, detectBrowser, detectVersion, isChromium, isSafari } from "./tools/utils/browserDetection.mjs";
+import { asyncRunOnReadyState, runOnReadyState } from "./browser/runOnReadyState.mjs";
+import { initXhrObservable } from "./browser/xhrObservable.mjs";
+import { readBytesFromStream } from "./tools/readBytesFromStream.mjs";
+import { ResponseBodyAction, initFetchObservable } from "./browser/fetchObservable.mjs";
+import { initWebSocketObservable } from "./browser/webSocketObservable.mjs";
+import { requestIdleCallback } from "./tools/requestIdleCallback.mjs";
+import { MAX_EXECUTION_TIME_ON_TIMEOUT, createTaskQueue } from "./tools/taskQueue.mjs";
+import { TIMEOUT_ERROR_MESSAGE, isThenable, isTimeoutError, waitForThenable } from "./tools/thenable.mjs";
+import { initConsoleObservable } from "./domain/console/consoleObservable.mjs";
+import { checkContext } from "./domain/context/contextUtils.mjs";
+import { createContextManager } from "./domain/context/contextManager.mjs";
+import { bufferContextCalls, defineContextMethod } from "./domain/context/defineContextMethod.mjs";
+import { removeStorageListeners, storeContextManager } from "./domain/context/storeContextManager.mjs";
+import { ContextManagerMethod, CustomerContextKey, CustomerDataType } from "./domain/context/contextConstants.mjs";
+import { buildAccountContextManager, startAccountContext } from "./domain/contexts/accountContext.mjs";
+import { startTabContext } from "./domain/contexts/tabContext.mjs";
+import { buildGlobalContextManager, startGlobalContext } from "./domain/contexts/globalContext.mjs";
+import { buildUserContextManager, startUserContext } from "./domain/contexts/userContext.mjs";
+import { getSyntheticsContext, isSyntheticsTest, willSyntheticsInjectRum } from "./domain/synthetics/syntheticsWorkerValues.mjs";
+import { RequestType, ResourceType } from "./domain/resourceUtils.mjs";
+import { BufferedDataType, startBufferingData } from "./domain/bufferedData.mjs";
+import { getTimeZone } from "./tools/utils/timezone.mjs";
+import { canUseGeoLocation, clearWatch, getCurrentPosition, watchPosition } from "./domain/geo/geolocation.mjs";
+import { getLocationName, reverseGeocode, reverseGeocodeAsync, reverseGeocodeWithPosition, reverseGeocodeWithPositionAsync } from "./domain/geo/geocoding.mjs";
+import { isNumber, round } from "./tools/utils/numberUtils.mjs";
+import { safeStringify, safeToString } from "./tools/serialisation/stringify.mjs";
+import { DeflateEncoderStreamId } from "./domain/deflate/deflate.types.mjs";
+import { getSyncUserAgentContext, resolveHighEntropyUserAgentContext } from "./domain/userAgentData/userAgentData.mjs";
+import { startTelemetrySessionContext } from "./domain/contexts/telemetrySessionContext.mjs";
+export { AbstractLifeCycle, BROWSER_CORE_SCHEMA, BridgeCapability, Browser, BufferedDataType, BufferedObservable, CLEAR_OLD_VALUES_INTERVAL, ContextManagerMethod, CustomerContextKey, CustomerDataType, DEFAULT_ERROR_TYPE, DOCS_TROUBLESHOOTING, DOM_EVENT, DefaultPrivacyLevel, DeflateEncoderStreamId, ErrorHandling, ErrorSource, ExperimentalFeature, FLUSH_DURATION_LIMIT, MAX_EXECUTION_TIME_ON_TIMEOUT, MEMORY_SESSION_STORE_KEY, NO_ERROR_STACK_PRESENT_MESSAGE, NonErrorPrefix, ONE_KIBI_BYTE, ONE_MEBI_BYTE, Observable, PageExitReason, RawReportType, RequestType, ResourceType, ResponseBodyAction, SANITIZE_DEFAULT_MAX_CHARACTER_COUNT, SDK_CONFIG_CACHE_KEY, SDK_CONFIG_PATH, SESSION_EXPIRATION_DELAY, SESSION_NOT_TRACKED, SESSION_STORE_KEY, SESSION_TIME_OUT_DELAY, SessionPersistence, TAG_SIZE_LIMIT, TIMEOUT_ERROR_MESSAGE, TelemetryMetrics, TelemetryService, TraceContextInjection, TrackingConsent, addEventListener, addEventListeners, addExperimentalFeatures, addTelemetryConfiguration, addTelemetryDebug, addTelemetryError, addTelemetryMetrics, addTelemetryUsage, asyncRunOnReadyState, bridgeSupports, bufferContextCalls, buildAccountContextManager, buildDebugIdByUrl, buildGlobalContextManager, buildSdkConfigEndpoint, buildTag, buildTags, buildUserContextManager, canUseEventBridge, canUseGeoLocation, catchUserErrors, checkContext, clearCachedSdkConfig, clearInterval, clearTimeout, clearWatch, computeBytesCount, computeRawError, computeStackTrace, concatBuffers, correctedChildSampleRate, createBatch, createContextManager, createEventRateLimiter, createFlushController, createHandlingStack, createHttpRequest, createIdentityEncoder, createPageMayExitObservable, createTaskQueue, createTrackingConsentState, createValueHistory, defineContextMethod, defineGlobal, deleteCookie, detachToJsonMethod, detectBrowser, detectVersion, display, displayAlreadyInitializedError, fetch, findAllCommaSeparatedValues, findCommaSeparatedValue, findCommaSeparatedValues, findLast, formatErrorMessage, generateUUID, getCachedSdkConfig, getConnectivity, getConstructorName, getCookie, getCurrentPosition, getEventBridge, getExperimentalFeatures, getFileFromStackTraceString, getInitCookie, getLocationName, getSessionEndClocks, getSourceCodeContext, getStackTraceUrls, getSyncUserAgentContext, getSyntheticsContext, getTimeZone, getZoneJsOriginalValue, initConsoleObservable, initFeatureFlags, initFetchObservable, initReportObservable, initWebSocketObservable, initXhrObservable, instrumentConstructor, instrumentMethod, instrumentSetter, isAllowedTrackingOrigins, isChromium, isCookieStoreSupported, isEmptyObject, isError, isEventSupported, isExperimentalFeatureEnabled, isNonEmptyArray, isNumber, isPageExitReason, isSafari, isSampled, isServerError, isSyntheticsTest, isThenable, isTimeoutError, jsonStringify, makePublicApi, mapValues, matchList, mergeArrays, mockable, noop, objectEntries, objectHasValue, objectValues, parseSdkConfig, readBoolean, readBytesFromStream, readEnum, readNumberInRange, readSampleRate, readString, readStringList, refreshSdkConfig, removeDuplicates, removeItem, removeStorageListeners, requestIdleCallback, resetAllowUntrustedEvents, resetInitCookies, resetSampleDecisionCache, resolveHighEntropyUserAgentContext, reverseGeocode, reverseGeocodeAsync, reverseGeocodeWithPosition, reverseGeocodeWithPositionAsync, round, runOnReadyState, safeStringify, safeToString, safeTruncate, sampleUsingKnuthFactor, sanitize, sanitizeTag, sendToExtension, serializeConfiguration, setAllowUntrustedEvents, setCachedSdkConfig, setCookie, setInterval, setTimeout, shallowClone, startAccountContext, startBufferingData, startGlobalContext, startSessionManager, startSessionManagerStub, startTabContext, startTelemetry, startTelemetrySessionContext, startUserContext, stopSessionManager, storeContextManager, throttle, toIntegrations, toMajorVersionIntegration, toStackTraceString, trackRuntimeError, tryJsonParse, tryToClone, waitForThenable, watchPosition, willSyntheticsInjectRum };

package/esm/tools/abstractLifeCycle.mjs

@@ -0,0 +1,21 @@
+//#region src/tools/abstractLifeCycle.ts
+var AbstractLifeCycle = class {
+	constructor() {
+		this.callbacks = {};
+	}
+	notify(eventType, data) {
+		const eventCallbacks = this.callbacks[eventType];
+		if (eventCallbacks) eventCallbacks.forEach((callback) => callback(data));
+	}
+	subscribe(eventType, callback) {
+		if (!this.callbacks[eventType]) this.callbacks[eventType] = [];
+		this.callbacks[eventType].push(callback);
+		return { unsubscribe: () => {
+			this.callbacks[eventType] = this.callbacks[eventType].filter((other) => callback !== other);
+		} };
+	}
+};
+//#endregion
+export { AbstractLifeCycle };
+
+//# sourceMappingURL=abstractLifeCycle.mjs.map

package/esm/tools/abstractLifeCycle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractLifeCycle.mjs","names":[],"sources":["../../src/tools/abstractLifeCycle.ts"],"sourcesContent":["import type { Subscription } from './observable'\n\n/**\n * Type helper to extract event types that have \"void\" data. This allows to call `notify` without a\n * second argument. Ex:\n *\n * ```\n * interface EventMap {\n *   foo: void\n * }\n * const LifeCycle = AbstractLifeCycle<EventMap>\n * new LifeCycle().notify('foo')\n * ```\n */\ntype EventTypesWithoutData<EventMap> = {\n  [K in keyof EventMap]: EventMap[K] extends void ? K : never\n}[keyof EventMap]\n\n// eslint-disable-next-line no-restricted-syntax\nexport class AbstractLifeCycle<EventMap> {\n  private callbacks: { [key in keyof EventMap]?: Array<(data: any) => void> } = {}\n\n  notify<EventType extends EventTypesWithoutData<EventMap>>(eventType: EventType): void\n  notify<EventType extends keyof EventMap>(eventType: EventType, data: EventMap[EventType]): void\n  notify(eventType: keyof EventMap, data?: unknown) {\n    const eventCallbacks = this.callbacks[eventType]\n    if (eventCallbacks) {\n      eventCallbacks.forEach((callback) => callback(data))\n    }\n  }\n\n  subscribe<EventType extends keyof EventMap>(\n    eventType: EventType,\n    callback: (data: EventMap[EventType]) => void\n  ): Subscription {\n    if (!this.callbacks[eventType]) {\n      this.callbacks[eventType] = []\n    }\n    this.callbacks[eventType]!.push(callback)\n    return {\n      unsubscribe: () => {\n        this.callbacks[eventType] = this.callbacks[eventType]!.filter((other) => callback !== other)\n      },\n    }\n  }\n}\n"],"mappings":";AAmBA,IAAa,oBAAb,MAAyC;;EACuC,KAAA,YAAA,CAAC;;CAI/E,OAAO,WAA2B,MAAgB;EAChD,MAAM,iBAAiB,KAAK,UAAU;EACtC,IAAI,gBACF,eAAe,SAAS,aAAa,SAAS,IAAI,CAAC;CAEvD;CAEA,UACE,WACA,UACc;EACd,IAAI,CAAC,KAAK,UAAU,YAClB,KAAK,UAAU,aAAa,CAAC;EAE/B,KAAK,UAAU,UAAU,CAAE,KAAK,QAAQ;EACxC,OAAO,EACL,mBAAmB;GACjB,KAAK,UAAU,aAAa,KAAK,UAAU,UAAU,CAAE,QAAQ,UAAU,aAAa,KAAK;EAC7F,EACF;CACF;AACF"}

package/esm/tools/catchUserErrors.mjs

@@ -0,0 +1,15 @@
+import { display } from "./display.mjs";
+//#region src/tools/catchUserErrors.ts
+function catchUserErrors(fn, errorMsg) {
+	return (...args) => {
+		try {
+			return fn(...args);
+		} catch (err) {
+			display.error(errorMsg, err);
+		}
+	};
+}
+//#endregion
+export { catchUserErrors };
+
+//# sourceMappingURL=catchUserErrors.mjs.map

package/esm/tools/catchUserErrors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"catchUserErrors.mjs","names":[],"sources":["../../src/tools/catchUserErrors.ts"],"sourcesContent":["import { display } from './display'\n\nexport function catchUserErrors<Args extends any[], R>(fn: (...args: Args) => R, errorMsg: string) {\n  return (...args: Args) => {\n    try {\n      return fn(...args)\n    } catch (err) {\n      display.error(errorMsg, err)\n    }\n  }\n}\n"],"mappings":";;AAEA,SAAgB,gBAAuC,IAA0B,UAAkB;CACjG,QAAQ,GAAG,SAAe;EACxB,IAAI;GACF,OAAO,GAAG,GAAG,IAAI;EACnB,SAAS,KAAK;GACZ,QAAQ,MAAM,UAAU,GAAG;EAC7B;CACF;AACF"}

package/esm/tools/display.mjs

@@ -0,0 +1,8 @@
+import { DOCS_ORIGIN, createDisplay } from "@kubesense/kubesense-js-core/util";
+//#region src/tools/display.ts
+const display = createDisplay("KubeSense Browser SDK:");
+const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/rum/browser/troubleshooting`;
+//#endregion
+export { DOCS_TROUBLESHOOTING, display };
+
+//# sourceMappingURL=display.mjs.map

package/esm/tools/display.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.mjs","names":[],"sources":["../../src/tools/display.ts"],"sourcesContent":["/* eslint-disable local-rules/disallow-side-effects */\nimport { createDisplay, DOCS_ORIGIN } from '@kubesense/kubesense-js-core/util'\n\nexport const display = createDisplay('KubeSense Browser SDK:')\n\nexport const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/rum/browser/troubleshooting`\n"],"mappings":";;AAGA,MAAa,UAAU,cAAc,wBAAwB;AAE7D,MAAa,uBAAuB,GAAG,YAAY"}

package/esm/tools/encoder.mjs

@@ -0,0 +1,39 @@
+import { computeBytesCount } from "./utils/byteUtils.mjs";
+//#region src/tools/encoder.ts
+function createIdentityEncoder() {
+	let output = "";
+	let outputBytesCount = 0;
+	return {
+		isAsync: false,
+		get isEmpty() {
+			return !output;
+		},
+		write(data, callback) {
+			const additionalEncodedBytesCount = computeBytesCount(data);
+			outputBytesCount += additionalEncodedBytesCount;
+			output += data;
+			if (callback) callback(additionalEncodedBytesCount);
+		},
+		finish(callback) {
+			callback(this.finishSync());
+		},
+		finishSync() {
+			const result = {
+				output,
+				outputBytesCount,
+				rawBytesCount: outputBytesCount,
+				pendingData: ""
+			};
+			output = "";
+			outputBytesCount = 0;
+			return result;
+		},
+		estimateEncodedBytesCount(data) {
+			return data.length;
+		}
+	};
+}
+//#endregion
+export { createIdentityEncoder };
+
+//# sourceMappingURL=encoder.mjs.map

package/esm/tools/encoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.mjs","names":[],"sources":["../../src/tools/encoder.ts"],"sourcesContent":["import type { Uint8ArrayBuffer } from './utils/byteUtils'\nimport { computeBytesCount } from './utils/byteUtils'\n\nexport interface Encoder<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {\n  /**\n   * Whether this encoder might call the provided callbacks asynchronously\n   */\n  isAsync: boolean\n\n  /**\n   * Whether some data has been written since the last finish() or finishSync() call\n   */\n  isEmpty: boolean\n\n  /**\n   * Write a string to be encoded.\n   *\n   * This operation can be synchronous or asynchronous depending on the encoder implementation.\n   *\n   * If specified, the callback will be invoked when the operation finishes, unless the operation is\n   * asynchronous and finish() or finishSync() is called in the meantime.\n   */\n  write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void\n\n  /**\n   * Waits for pending data to be encoded and resets the encoder state.\n   *\n   * This operation can be synchronous or asynchronous depending on the encoder implementation.\n   *\n   * The callback will be invoked when the operation finishes, unless the operation is asynchronous\n   * and another call to finish() or finishSync() occurs in the meantime.\n   */\n  finish(callback: (result: EncoderResult<Output>) => void): void\n\n  /**\n   * Resets the encoder state then returns the encoded data and any potential pending data directly,\n   * discarding all pending write operations and finish() callbacks.\n   */\n  finishSync(): EncoderResult<Output> & { pendingData: string }\n\n  /**\n   * Returns a rough estimation of the bytes count if the data was encoded.\n   */\n  estimateEncodedBytesCount(data: string): number\n}\n\nexport interface EncoderResult<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {\n  output: Output\n  outputBytesCount: number\n\n  /**\n   * An encoding type supported by HTTP Content-Encoding, if applicable.\n   * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives\n   */\n  encoding?: 'deflate'\n\n  /**\n   * Total bytes count of the input strings encoded to UTF-8.\n   */\n  rawBytesCount: number\n}\n\nexport function createIdentityEncoder(): Encoder<string> {\n  let output = ''\n  let outputBytesCount = 0\n\n  return {\n    isAsync: false,\n\n    get isEmpty() {\n      return !output\n    },\n\n    write(data, callback) {\n      const additionalEncodedBytesCount = computeBytesCount(data)\n      outputBytesCount += additionalEncodedBytesCount\n      output += data\n      if (callback) {\n        callback(additionalEncodedBytesCount)\n      }\n    },\n\n    finish(callback) {\n      callback(this.finishSync())\n    },\n\n    finishSync() {\n      const result = {\n        output,\n        outputBytesCount,\n        rawBytesCount: outputBytesCount,\n        pendingData: '',\n      }\n      output = ''\n      outputBytesCount = 0\n      return result\n    },\n\n    estimateEncodedBytesCount(data) {\n      return data.length\n    },\n  }\n}\n"],"mappings":";;AA8DA,SAAgB,wBAAyC;CACvD,IAAI,SAAS;CACb,IAAI,mBAAmB;CAEvB,OAAO;EACL,SAAS;EAET,IAAI,UAAU;GACZ,OAAO,CAAC;EACV;EAEA,MAAM,MAAM,UAAU;GACpB,MAAM,8BAA8B,kBAAkB,IAAI;GAC1D,oBAAoB;GACpB,UAAU;GACV,IAAI,UACF,SAAS,2BAA2B;EAExC;EAEA,OAAO,UAAU;GACf,SAAS,KAAK,WAAW,CAAC;EAC5B;EAEA,aAAa;GACX,MAAM,SAAS;IACb;IACA;IACA,eAAe;IACf,aAAa;GACf;GACA,SAAS;GACT,mBAAmB;GACnB,OAAO;EACT;EAEA,0BAA0B,MAAM;GAC9B,OAAO,KAAK;EACd;CACF;AACF"}

package/esm/tools/experimentalFeatures.mjs

@@ -0,0 +1,35 @@
+import { objectHasValue } from "./utils/objectUtils.mjs";
+//#region src/tools/experimentalFeatures.ts
+/**
+* LIMITATION:
+* For NPM setup, this feature flag singleton is shared between RUM and Logs product.
+* This means that an experimental flag set on the RUM product will be set on the Logs product.
+* So keep in mind that in certain configurations, your experimental feature flag may affect other products.
+*
+* FORMAT:
+* All feature flags should be snake_cased
+*/
+let ExperimentalFeature = /* @__PURE__ */ function(ExperimentalFeature) {
+	ExperimentalFeature["TRACK_INTAKE_REQUESTS"] = "track_intake_requests";
+	ExperimentalFeature["TRACK_WEBSOCKETS"] = "track_websockets";
+	return ExperimentalFeature;
+}({});
+const enabledExperimentalFeatures = /* @__PURE__ */ new Set();
+function initFeatureFlags(enableExperimentalFeatures) {
+	if (Array.isArray(enableExperimentalFeatures)) addExperimentalFeatures(enableExperimentalFeatures.filter((flag) => objectHasValue(ExperimentalFeature, flag)));
+}
+function addExperimentalFeatures(enabledFeatures) {
+	enabledFeatures.forEach((flag) => {
+		enabledExperimentalFeatures.add(flag);
+	});
+}
+function isExperimentalFeatureEnabled(featureName) {
+	return enabledExperimentalFeatures.has(featureName);
+}
+function getExperimentalFeatures() {
+	return enabledExperimentalFeatures;
+}
+//#endregion
+export { ExperimentalFeature, addExperimentalFeatures, getExperimentalFeatures, initFeatureFlags, isExperimentalFeatureEnabled };
+
+//# sourceMappingURL=experimentalFeatures.mjs.map