@kubesense/kubesense-browser-logs 0.0.0-stage → 2.0.0-beta.1

package/esm/boot/logsPublicApi.mjs

@@ -0,0 +1,75 @@
+import { Logger } from "../domain/logger.mjs";
+import { buildCommonContext } from "../domain/contexts/commonContext.mjs";
+import { callPluginsMethod } from "../domain/plugins.mjs";
+import { startLogs } from "./startLogs.mjs";
+import { createPreStartStrategy } from "./preStartLogs.mjs";
+import { deepClone } from "@kubesense/kubesense-js-core/util";
+import { ContextManagerMethod, CustomerContextKey, addTelemetryUsage, createTrackingConsentState, defineContextMethod, displayAlreadyInitializedError, makePublicApi, mockable, sanitize, startBufferingData } from "@kubesense/kubesense-browser-core";
+import { callMonitored, monitor } from "@kubesense/kubesense-js-core/monitor";
+//#region src/boot/logsPublicApi.ts
+function makeLogsPublicApi(options = {}) {
+	const trackingConsentState = createTrackingConsentState();
+	const bufferedDataObservable = startBufferingData().observable;
+	let strategy = createPreStartStrategy(buildCommonContext, trackingConsentState, (configuration, logsSessionManager, hooks) => {
+		const startLogsResult = mockable(startLogs)(configuration, logsSessionManager, buildCommonContext, bufferedDataObservable, hooks);
+		strategy = createPostStartStrategy(strategy, startLogsResult);
+		callPluginsMethod(configuration.plugins, "onLogsStart", { handleLog: startLogsResult.handleLog });
+		return startLogsResult;
+	}, options.sdkName);
+	const getStrategy = () => strategy;
+	const customLoggers = {};
+	const mainLogger = new Logger((...params) => strategy.handleLog(...params));
+	const logsPublicApi = makePublicApi({
+		logger: mainLogger,
+		init: (initConfiguration) => {
+			const errorStack = (/* @__PURE__ */ new Error()).stack;
+			callMonitored(() => strategy.init(initConfiguration, logsPublicApi, errorStack));
+		},
+		setTrackingConsent: monitor((trackingConsent) => {
+			trackingConsentState.update(trackingConsent);
+			addTelemetryUsage({
+				feature: "set-tracking-consent",
+				tracking_consent: trackingConsent
+			});
+		}),
+		getGlobalContext: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.getContext),
+		setGlobalContext: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.setContext),
+		setGlobalContextProperty: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.setContextProperty),
+		removeGlobalContextProperty: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.removeContextProperty),
+		clearGlobalContext: defineContextMethod(getStrategy, CustomerContextKey.globalContext, ContextManagerMethod.clearContext),
+		createLogger: monitor((name, conf = {}) => {
+			customLoggers[name] = new Logger((...params) => strategy.handleLog(...params), sanitize(name), conf.handler, conf.level, sanitize(conf.context));
+			return customLoggers[name];
+		}),
+		getLogger: monitor((name) => customLoggers[name]),
+		getInitConfiguration: monitor(() => deepClone(strategy.initConfiguration)),
+		getInternalContext: monitor((startTime) => strategy.getInternalContext(startTime)),
+		setUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.setContext),
+		getUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.getContext),
+		setUserProperty: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.setContextProperty),
+		removeUserProperty: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.removeContextProperty),
+		clearUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.clearContext),
+		setAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.setContext),
+		getAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.getContext),
+		setAccountProperty: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.setContextProperty),
+		removeAccountProperty: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.removeContextProperty),
+		clearAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.clearContext)
+	});
+	return logsPublicApi;
+}
+function createPostStartStrategy(preStartStrategy, startLogsResult) {
+	return {
+		...preStartStrategy,
+		init: (initConfiguration) => {
+			displayAlreadyInitializedError("KUBESENSE_LOGS", initConfiguration);
+		},
+		getInternalContext: startLogsResult.getInternalContext,
+		globalContext: startLogsResult.globalContext,
+		userContext: startLogsResult.userContext,
+		accountContext: startLogsResult.accountContext
+	};
+}
+//#endregion
+export { makeLogsPublicApi };
+
+//# sourceMappingURL=logsPublicApi.mjs.map

package/esm/boot/logsPublicApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logsPublicApi.mjs","names":[],"sources":["../../src/boot/logsPublicApi.ts"],"sourcesContent":["import type {\n  TrackingConsent,\n  PublicApi,\n  ContextManager,\n  Account,\n  Context,\n  User,\n} from '@kubesense/kubesense-browser-core'\nimport {\n  ContextManagerMethod,\n  CustomerContextKey,\n  addTelemetryUsage,\n  makePublicApi,\n  sanitize,\n  displayAlreadyInitializedError,\n  createTrackingConsentState,\n  defineContextMethod,\n  startBufferingData,\n  mockable,\n} from '@kubesense/kubesense-browser-core'\nimport { monitor, callMonitored } from '@kubesense/kubesense-js-core/monitor'\nimport { deepClone } from '@kubesense/kubesense-js-core/util'\nimport type { LogsInitConfiguration } from '../domain/configuration'\nimport type { HandlerType } from '../domain/logger'\nimport type { StatusType } from '../domain/logger/isAuthorized'\nimport { Logger } from '../domain/logger'\nimport { buildCommonContext } from '../domain/contexts/commonContext'\nimport { callPluginsMethod } from '../domain/plugins'\nimport type { InternalContext } from '../domain/contexts/internalContext'\nimport type { StartLogsResult } from './startLogs'\nimport { startLogs } from './startLogs'\nimport { createPreStartStrategy } from './preStartLogs'\n\nexport interface LoggerConfiguration {\n  level?: StatusType\n  handler?: HandlerType | HandlerType[]\n  context?: object\n}\n\n/**\n * Public API for the Logs browser SDK.\n *\n * See [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript) for further information.\n *\n * @category Main\n */\nexport interface LogsPublicApi extends PublicApi {\n  /**\n   * The default logger\n   *\n   * @category Logger\n   */\n  logger: Logger\n\n  /**\n   * Init the Logs browser SDK.\n   *\n   * See [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript) for further information.\n   *\n   * @category Init\n   * @param initConfiguration - Configuration options of the SDK\n   */\n  init: (initConfiguration: LogsInitConfiguration) => void\n\n  /**\n   * Set the tracking consent of the current user.\n   *\n   * Logs will be sent only if it is set to \"granted\". This value won't be stored by the library\n   * across page loads: you will need to call this method or set the appropriate `trackingConsent`\n   * field in the init() method at each page load.\n   *\n   * If this method is called before the init() method, the provided value will take precedence\n   * over the one provided as initialization parameter.\n   *\n   * See [User tracking consent](https://docs.kubesense.ai/logs/log_collection/javascript/#user-tracking-consent) for further information.\n   *\n   * @category Privacy\n   * @param trackingConsent - The user tracking consent\n   */\n  setTrackingConsent: (trackingConsent: TrackingConsent) => void\n\n  /**\n   * Set the global context information to all events, stored in `@context`\n   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.\n   *\n   * @category Context - Global Context\n   * @param context - Global context\n   */\n  setGlobalContext: (context: any) => void\n\n  /**\n   * Get the global Context\n   *\n   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.\n   *\n   * @category Context - Global Context\n   */\n  getGlobalContext: () => Context\n\n  /**\n   * Set or update a global context property, stored in `@context.<key>`\n   *\n   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.\n   *\n   * @category Context - Global Context\n   * @param key - Key of the property\n   * @param value - Value of the property\n   */\n  setGlobalContextProperty: (key: any, value: any) => void\n\n  /**\n   * Remove a global context property\n   *\n   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.\n   *\n   * @category Context - Global Context\n   */\n  removeGlobalContextProperty: (key: any) => void\n\n  /**\n   * Clear the global context\n   *\n   * See [Global context](https://docs.kubesense.ai/logs/log_collection/javascript/#overwrite-context) for further information.\n   *\n   * @category Context - Global Context\n   */\n  clearGlobalContext: () => void\n\n  /**\n   * Set user information to all events, stored in `@usr`\n   *\n   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.\n   *\n   * @category Context - User\n   * @param newUser - User information\n   */\n  setUser(newUser: User & { id: string }): void\n\n  /**\n   * Set user information to all events, stored in `@usr`\n   *\n   * @category Context - User\n   * @deprecated You must specify a user id, favor using {@link setUser} instead\n   * @param newUser - User information with optional id\n   */\n  setUser(newUser: User): void\n\n  /**\n   * Get user information\n   *\n   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.\n   *\n   * @category Context - User\n   * @returns User information\n   */\n  getUser: () => Context\n\n  /**\n   * Set or update the user property, stored in `@usr.<key>`\n   *\n   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.\n   *\n   * @category Context - User\n   * @param key - Key of the property\n   * @param property - Value of the property\n   */\n  setUserProperty: (key: any, property: any) => void\n\n  /**\n   * Remove a user property\n   *\n   * @category Context - User\n   * @param key - Key of the property to remove\n   * @see [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.\n   */\n  removeUserProperty: (key: any) => void\n\n  /**\n   * Clear all user information\n   *\n   * See [User session](https://docs.kubesense.ai/logs/log_collection/javascript/#user-context) for further information.\n   *\n   * @category Context - User\n   */\n  clearUser: () => void\n\n  /**\n   * Set account information to all events, stored in `@account`\n   *\n   * @category Context - Account\n   * @param newAccount - Account information\n   */\n  setAccount: (newAccount: Account) => void\n\n  /**\n   * Get account information\n   *\n   * @category Context - Account\n   * @returns Account information\n   */\n  getAccount: () => Context\n\n  /**\n   * Set or update the account property, stored in `@account.<key>`\n   *\n   * @category Context - Account\n   * @param key - Key of the property\n   * @param property - Value of the property\n   */\n  setAccountProperty: (key: string, property: any) => void\n\n  /**\n   * Remove an account property\n   *\n   * @category Context - Account\n   * @param key - Key of the property to remove\n   */\n  removeAccountProperty: (key: string) => void\n\n  /**\n   * Clear all account information\n   *\n   * @category Context - Account\n   * @returns Clear all account information\n   */\n  clearAccount: () => void\n\n  /**\n   * The KubeSense browser logs SDK contains a default logger `KUBESENSE_LOGS.logger`, but this API allows to create different ones.\n   *\n   * See [Define multiple loggers](https://docs.kubesense.ai/logs/log_collection/javascript/#define-multiple-loggers) for further information.\n   *\n   * @category Logger\n   * @param name - Name of the logger\n   * @param conf - Configuration of the logger (level, handler, context)\n   */\n  createLogger: (name: string, conf?: LoggerConfiguration) => Logger\n\n  /**\n   * Get a logger\n   *\n   * See [Define multiple loggers](https://docs.kubesense.ai/logs/log_collection/javascript/#define-multiple-loggers) for further information.\n   *\n   * @category Logger\n   * @param name - Name of the logger\n   */\n  getLogger: (name: string) => Logger | undefined\n\n  /**\n   * Get the init configuration\n   *\n   * @category Init\n   * @returns The init configuration\n   */\n  getInitConfiguration: () => LogsInitConfiguration | undefined\n\n  /**\n   * [Internal API] Get the internal SDK context\n   *\n   * See [Access internal context](https://docs.kubesense.ai/logs/log_collection/javascript/#access-internal-context) for further information.\n   *\n   * @internal\n   */\n  getInternalContext: (startTime?: number) => InternalContext | undefined\n}\n\nexport interface Strategy {\n  init: (initConfiguration: LogsInitConfiguration, publicApi: LogsPublicApi, errorStack?: string) => void\n  initConfiguration: LogsInitConfiguration | undefined\n  globalContext: ContextManager\n  accountContext: ContextManager\n  userContext: ContextManager\n  getInternalContext: StartLogsResult['getInternalContext']\n  handleLog: StartLogsResult['handleLog']\n}\n\nexport interface LogsPublicApiOptions {\n  sdkName?: string\n}\n\nexport function makeLogsPublicApi(options: LogsPublicApiOptions = {}): LogsPublicApi {\n  const trackingConsentState = createTrackingConsentState()\n  const bufferedDataObservable = startBufferingData().observable\n\n  let strategy = createPreStartStrategy(\n    buildCommonContext,\n    trackingConsentState,\n    (configuration, logsSessionManager, hooks) => {\n      const startLogsResult = mockable(startLogs)(\n        configuration,\n        logsSessionManager,\n        buildCommonContext,\n        bufferedDataObservable,\n        hooks\n      )\n\n      strategy = createPostStartStrategy(strategy, startLogsResult)\n      callPluginsMethod(configuration.plugins, 'onLogsStart', {\n        handleLog: startLogsResult.handleLog,\n      })\n      return startLogsResult\n    },\n    options.sdkName\n  )\n\n  const getStrategy = () => strategy\n\n  const customLoggers: { [name: string]: Logger | undefined } = {}\n\n  const mainLogger = new Logger((...params) => strategy.handleLog(...params))\n\n  const logsPublicApi: LogsPublicApi = makePublicApi<LogsPublicApi>({\n    logger: mainLogger,\n\n    init: (initConfiguration) => {\n      const errorStack = new Error().stack\n      callMonitored(() => strategy.init(initConfiguration, logsPublicApi, errorStack))\n    },\n\n    setTrackingConsent: monitor((trackingConsent) => {\n      trackingConsentState.update(trackingConsent)\n      addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent })\n    }),\n\n    getGlobalContext: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.globalContext,\n      ContextManagerMethod.getContext\n    ),\n    setGlobalContext: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.globalContext,\n      ContextManagerMethod.setContext\n    ),\n\n    setGlobalContextProperty: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.globalContext,\n      ContextManagerMethod.setContextProperty\n    ),\n\n    removeGlobalContextProperty: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.globalContext,\n      ContextManagerMethod.removeContextProperty\n    ),\n\n    clearGlobalContext: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.globalContext,\n      ContextManagerMethod.clearContext\n    ),\n\n    createLogger: monitor((name, conf = {}) => {\n      customLoggers[name] = new Logger(\n        (...params) => strategy.handleLog(...params),\n        sanitize(name),\n        conf.handler,\n        conf.level,\n        sanitize(conf.context) as object\n      )\n\n      return customLoggers[name]\n    }),\n\n    getLogger: monitor((name) => customLoggers[name]),\n\n    getInitConfiguration: monitor(() => deepClone(strategy.initConfiguration)),\n\n    getInternalContext: monitor((startTime) => strategy.getInternalContext(startTime)),\n\n    setUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.setContext),\n\n    getUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.getContext),\n\n    setUserProperty: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.userContext,\n      ContextManagerMethod.setContextProperty\n    ),\n\n    removeUserProperty: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.userContext,\n      ContextManagerMethod.removeContextProperty\n    ),\n\n    clearUser: defineContextMethod(getStrategy, CustomerContextKey.userContext, ContextManagerMethod.clearContext),\n\n    setAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.setContext),\n\n    getAccount: defineContextMethod(getStrategy, CustomerContextKey.accountContext, ContextManagerMethod.getContext),\n\n    setAccountProperty: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.accountContext,\n      ContextManagerMethod.setContextProperty\n    ),\n\n    removeAccountProperty: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.accountContext,\n      ContextManagerMethod.removeContextProperty\n    ),\n\n    clearAccount: defineContextMethod(\n      getStrategy,\n      CustomerContextKey.accountContext,\n      ContextManagerMethod.clearContext\n    ),\n  })\n\n  return logsPublicApi\n}\n\nfunction createPostStartStrategy(preStartStrategy: Strategy, startLogsResult: StartLogsResult): Strategy {\n  return {\n    ...preStartStrategy,\n    init: (initConfiguration: LogsInitConfiguration) => {\n      displayAlreadyInitializedError('KUBESENSE_LOGS', initConfiguration)\n    },\n    getInternalContext: startLogsResult.getInternalContext,\n    globalContext: startLogsResult.globalContext,\n    userContext: startLogsResult.userContext,\n    accountContext: startLogsResult.accountContext,\n  }\n}\n"],"mappings":";;;;;;;;;AAwRA,SAAgB,kBAAkB,UAAgC,CAAC,GAAkB;CACnF,MAAM,uBAAuB,2BAA2B;CACxD,MAAM,yBAAyB,mBAAmB,CAAC,CAAC;CAEpD,IAAI,WAAW,uBACb,oBACA,uBACC,eAAe,oBAAoB,UAAU;EAC5C,MAAM,kBAAkB,SAAS,SAAS,CAAC,CACzC,eACA,oBACA,oBACA,wBACA,KACF;EAEA,WAAW,wBAAwB,UAAU,eAAe;EAC5D,kBAAkB,cAAc,SAAS,eAAe,EACtD,WAAW,gBAAgB,UAC7B,CAAC;EACD,OAAO;CACT,GACA,QAAQ,OACV;CAEA,MAAM,oBAAoB;CAE1B,MAAM,gBAAwD,CAAC;CAE/D,MAAM,aAAa,IAAI,QAAQ,GAAG,WAAW,SAAS,UAAU,GAAG,MAAM,CAAC;CAE1E,MAAM,gBAA+B,cAA6B;EAChE,QAAQ;EAER,OAAO,sBAAsB;GAC3B,MAAM,8BAAa,IAAI,MAAM,EAAA,CAAE;GAC/B,oBAAoB,SAAS,KAAK,mBAAmB,eAAe,UAAU,CAAC;EACjF;EAEA,oBAAoB,SAAS,oBAAoB;GAC/C,qBAAqB,OAAO,eAAe;GAC3C,kBAAkB;IAAE,SAAS;IAAwB,kBAAkB;GAAgB,CAAC;EAC1F,CAAC;EAED,kBAAkB,oBAChB,aACA,mBAAmB,eACnB,qBAAqB,UACvB;EACA,kBAAkB,oBAChB,aACA,mBAAmB,eACnB,qBAAqB,UACvB;EAEA,0BAA0B,oBACxB,aACA,mBAAmB,eACnB,qBAAqB,kBACvB;EAEA,6BAA6B,oBAC3B,aACA,mBAAmB,eACnB,qBAAqB,qBACvB;EAEA,oBAAoB,oBAClB,aACA,mBAAmB,eACnB,qBAAqB,YACvB;EAEA,cAAc,SAAS,MAAM,OAAO,CAAC,MAAM;GACzC,cAAc,QAAQ,IAAI,QACvB,GAAG,WAAW,SAAS,UAAU,GAAG,MAAM,GAC3C,SAAS,IAAI,GACb,KAAK,SACL,KAAK,OACL,SAAS,KAAK,OAAO,CACvB;GAEA,OAAO,cAAc;EACvB,CAAC;EAED,WAAW,SAAS,SAAS,cAAc,KAAK;EAEhD,sBAAsB,cAAc,UAAU,SAAS,iBAAiB,CAAC;EAEzE,oBAAoB,SAAS,cAAc,SAAS,mBAAmB,SAAS,CAAC;EAEjF,SAAS,oBAAoB,aAAa,mBAAmB,aAAa,qBAAqB,UAAU;EAEzG,SAAS,oBAAoB,aAAa,mBAAmB,aAAa,qBAAqB,UAAU;EAEzG,iBAAiB,oBACf,aACA,mBAAmB,aACnB,qBAAqB,kBACvB;EAEA,oBAAoB,oBAClB,aACA,mBAAmB,aACnB,qBAAqB,qBACvB;EAEA,WAAW,oBAAoB,aAAa,mBAAmB,aAAa,qBAAqB,YAAY;EAE7G,YAAY,oBAAoB,aAAa,mBAAmB,gBAAgB,qBAAqB,UAAU;EAE/G,YAAY,oBAAoB,aAAa,mBAAmB,gBAAgB,qBAAqB,UAAU;EAE/G,oBAAoB,oBAClB,aACA,mBAAmB,gBACnB,qBAAqB,kBACvB;EAEA,uBAAuB,oBACrB,aACA,mBAAmB,gBACnB,qBAAqB,qBACvB;EAEA,cAAc,oBACZ,aACA,mBAAmB,gBACnB,qBAAqB,YACvB;CACF,CAAC;CAED,OAAO;AACT;AAEA,SAAS,wBAAwB,kBAA4B,iBAA4C;CACvG,OAAO;EACL,GAAG;EACH,OAAO,sBAA6C;GAClD,+BAA+B,kBAAkB,iBAAiB;EACpE;EACA,oBAAoB,gBAAgB;EACpC,eAAe,gBAAgB;EAC/B,aAAa,gBAAgB;EAC7B,gBAAgB,gBAAgB;CAClC;AACF"}

package/esm/boot/preStartLogs.mjs

@@ -0,0 +1,105 @@
+import { callPluginsMethod } from "../domain/plugins.mjs";
+import { createHooks } from "../domain/hooks.mjs";
+import { serializeLogsConfiguration, validateAndBuildLogsConfiguration } from "../domain/configuration.mjs";
+import { applyCachedLogsSdkConfiguration, scheduleLogsSdkConfigurationRefresh } from "../domain/remoteSdkConfiguration.mjs";
+import { startTrackingConsentContext } from "../domain/contexts/trackingConsentContext.mjs";
+import { BufferedObservable, CustomerContextKey, TelemetryService, addTelemetryConfiguration, addTelemetryDebug, bufferContextCalls, buildAccountContextManager, buildGlobalContextManager, buildUserContextManager, canUseEventBridge, display, displayAlreadyInitializedError, initFeatureFlags, isAllowedTrackingOrigins, mockable, noop, setAllowUntrustedEvents, startSessionManager, startSessionManagerStub, startTelemetry, startTelemetrySessionContext } from "@kubesense/kubesense-browser-core";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/boot/preStartLogs.ts
+function createPreStartStrategy(getCommonContext, trackingConsentState, doStartLogs, sdkName) {
+	const bufferApiCalls = new BufferedObservable(500, (count) => {
+		addTelemetryDebug("preStartLogs buffer data lost", { count });
+	});
+	const globalContext = buildGlobalContextManager();
+	bufferContextCalls(globalContext, CustomerContextKey.globalContext, bufferApiCalls);
+	const accountContext = buildAccountContextManager();
+	bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls);
+	const userContext = buildUserContextManager();
+	bufferContextCalls(userContext, CustomerContextKey.userContext, bufferApiCalls);
+	let cachedInitConfiguration;
+	let cachedConfiguration;
+	let sessionManager;
+	const hooks = createHooks();
+	const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartLogs);
+	function tryStartLogs() {
+		if (!cachedConfiguration || !cachedInitConfiguration || !sessionManager) return;
+		trackingConsentStateSubscription.unsubscribe();
+		const startLogsResult = doStartLogs(cachedConfiguration, sessionManager, hooks);
+		bufferApiCalls.subscribe((callback) => callback(startLogsResult));
+		bufferApiCalls.unbuffer();
+	}
+	return {
+		init(initConfiguration, publicApi, errorStack) {
+			if (!initConfiguration) {
+				display.error("Missing configuration");
+				return;
+			}
+			initFeatureFlags(initConfiguration.enableExperimentalFeatures);
+			setAllowUntrustedEvents(initConfiguration.allowUntrustedEvents);
+			if (canUseEventBridge()) initConfiguration = overrideInitConfigurationForBridge(initConfiguration);
+			const remoteSdkConfigurationEnabled = !!initConfiguration.enableRemoteSdkConfiguration;
+			const refreshRemoteSdkConfiguration = () => {
+				if (remoteSdkConfigurationEnabled) scheduleLogsSdkConfigurationRefresh(initConfiguration).catch(noop);
+			};
+			if (remoteSdkConfigurationEnabled) {
+				const cachedSdkConfiguration = applyCachedLogsSdkConfiguration(initConfiguration);
+				initConfiguration = cachedSdkConfiguration.initConfiguration;
+				if (!cachedSdkConfiguration.logsEnabled) {
+					cachedInitConfiguration = initConfiguration;
+					refreshRemoteSdkConfiguration();
+					return;
+				}
+			}
+			cachedInitConfiguration = initConfiguration;
+			if (cachedConfiguration) {
+				displayAlreadyInitializedError("KUBESENSE_LOGS", initConfiguration);
+				return;
+			}
+			callPluginsMethod(initConfiguration.plugins, "onInit", {
+				initConfiguration,
+				publicApi,
+				registerAssembleEventHook: hooks.assembleEvent.register
+			});
+			const configuration = validateAndBuildLogsConfiguration(initConfiguration);
+			if (!configuration || !isAllowedTrackingOrigins(configuration, errorStack ?? "")) {
+				refreshRemoteSdkConfiguration();
+				return;
+			}
+			cachedConfiguration = configuration;
+			trackingConsentState.tryToInit(configuration.trackingConsent);
+			trackingConsentState.onGrantedOnce(() => {
+				startTrackingConsentContext(hooks, trackingConsentState);
+				mockable(startTelemetry)(TelemetryService.LOGS, configuration, hooks.assembleTelemetry, sdkName);
+				(canUseEventBridge() ? startSessionManagerStub() : mockable(startSessionManager)(configuration, trackingConsentState)).then((newSessionManager) => {
+					if (!newSessionManager) return;
+					sessionManager = newSessionManager;
+					startTelemetrySessionContext(hooks.assembleTelemetry, sessionManager);
+					addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration));
+					tryStartLogs();
+					refreshRemoteSdkConfiguration();
+				}).catch(monitorError);
+			});
+		},
+		get initConfiguration() {
+			return cachedInitConfiguration;
+		},
+		globalContext,
+		accountContext,
+		userContext,
+		getInternalContext: noop,
+		handleLog(message, statusType, handlingStack, context = getCommonContext(), date = timeStampNow()) {
+			bufferApiCalls.notify((startLogsResult) => startLogsResult.handleLog(message, statusType, handlingStack, context, date));
+		}
+	};
+}
+function overrideInitConfigurationForBridge(initConfiguration) {
+	return {
+		...initConfiguration,
+		clientToken: "empty"
+	};
+}
+//#endregion
+export { createPreStartStrategy };
+
+//# sourceMappingURL=preStartLogs.mjs.map

package/esm/boot/preStartLogs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preStartLogs.mjs","names":[],"sources":["../../src/boot/preStartLogs.ts"],"sourcesContent":["import { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport { monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport type { TrackingConsentState, SessionManager } from '@kubesense/kubesense-browser-core'\nimport {\n  BufferedObservable,\n  canUseEventBridge,\n  display,\n  displayAlreadyInitializedError,\n  initFeatureFlags,\n  noop,\n  buildAccountContextManager,\n  CustomerContextKey,\n  bufferContextCalls,\n  addTelemetryConfiguration,\n  addTelemetryDebug,\n  buildGlobalContextManager,\n  buildUserContextManager,\n  startSessionManager,\n  startSessionManagerStub,\n  startTelemetry,\n  TelemetryService,\n  mockable,\n  startTelemetrySessionContext,\n  setAllowUntrustedEvents,\n  isAllowedTrackingOrigins,\n} from '@kubesense/kubesense-browser-core'\nimport type { Hooks } from '../domain/hooks'\nimport { createHooks } from '../domain/hooks'\nimport type { LogsConfiguration, LogsInitConfiguration } from '../domain/configuration'\nimport { serializeLogsConfiguration, validateAndBuildLogsConfiguration } from '../domain/configuration'\nimport { applyCachedLogsSdkConfiguration, scheduleLogsSdkConfigurationRefresh } from '../domain/remoteSdkConfiguration'\nimport type { CommonContext } from '../rawLogsEvent.types'\nimport { startTrackingConsentContext } from '../domain/contexts/trackingConsentContext'\nimport { callPluginsMethod } from '../domain/plugins'\nimport type { Strategy } from './logsPublicApi'\nimport type { StartLogsResult } from './startLogs'\n\nexport type DoStartLogs = (\n  configuration: LogsConfiguration,\n  sessionManager: SessionManager,\n  hooks: Hooks\n) => StartLogsResult\n\nexport function createPreStartStrategy(\n  getCommonContext: () => CommonContext,\n  trackingConsentState: TrackingConsentState,\n  doStartLogs: DoStartLogs,\n  sdkName?: string\n): Strategy {\n  const BUFFER_LIMIT = 500\n  const bufferApiCalls = new BufferedObservable<(startLogsResult: StartLogsResult) => void>(BUFFER_LIMIT, (count) => {\n    // monitor-until: 2026-10-14\n    addTelemetryDebug('preStartLogs buffer data lost', { count })\n  })\n\n  // TODO next major: remove the globalContext, accountContextManager, userContext from preStartStrategy and use an empty context instead\n  const globalContext = buildGlobalContextManager()\n  bufferContextCalls(globalContext, CustomerContextKey.globalContext, bufferApiCalls)\n\n  const accountContext = buildAccountContextManager()\n  bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls)\n\n  const userContext = buildUserContextManager()\n  bufferContextCalls(userContext, CustomerContextKey.userContext, bufferApiCalls)\n\n  let cachedInitConfiguration: LogsInitConfiguration | undefined\n  let cachedConfiguration: LogsConfiguration | undefined\n  let sessionManager: SessionManager | undefined\n  const hooks = createHooks()\n  const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartLogs)\n\n  function tryStartLogs() {\n    if (!cachedConfiguration || !cachedInitConfiguration || !sessionManager) {\n      return\n    }\n\n    trackingConsentStateSubscription.unsubscribe()\n    const startLogsResult = doStartLogs(cachedConfiguration, sessionManager, hooks)\n\n    bufferApiCalls.subscribe((callback) => callback(startLogsResult))\n    bufferApiCalls.unbuffer()\n  }\n\n  return {\n    init(initConfiguration, publicApi, errorStack) {\n      if (!initConfiguration) {\n        display.error('Missing configuration')\n        return\n      }\n      // Set the experimental feature flags as early as possible, so we can use them in most places\n      initFeatureFlags(initConfiguration.enableExperimentalFeatures)\n      setAllowUntrustedEvents(initConfiguration.allowUntrustedEvents)\n\n      if (canUseEventBridge()) {\n        initConfiguration = overrideInitConfigurationForBridge(initConfiguration)\n      }\n\n      const remoteSdkConfigurationEnabled = !!initConfiguration.enableRemoteSdkConfiguration\n\n      // A cached document that stops Logs from starting must never be a one-way door: without a\n      // refresh on those paths the browser replays the same bad document on every load and can\n      // never learn about a corrected one.\n      const refreshRemoteSdkConfiguration = () => {\n        if (remoteSdkConfigurationEnabled) {\n          scheduleLogsSdkConfigurationRefresh(initConfiguration).catch(noop)\n        }\n      }\n\n      if (remoteSdkConfigurationEnabled) {\n        // Reading the cached document is synchronous and network-free, so it does not delay\n        // initialization. The document fetched below only applies from the next page load.\n        const cachedSdkConfiguration = applyCachedLogsSdkConfiguration(initConfiguration)\n        initConfiguration = cachedSdkConfiguration.initConfiguration\n\n        if (!cachedSdkConfiguration.logsEnabled) {\n          // Logs is switched off from the dashboard. Still refresh the document, otherwise the\n          // switch would be one-way: the SDK could never learn it has been turned back on.\n          cachedInitConfiguration = initConfiguration\n          refreshRemoteSdkConfiguration()\n          return\n        }\n      }\n\n      // Expose the initial configuration regardless of initialization success.\n      cachedInitConfiguration = initConfiguration\n\n      if (cachedConfiguration) {\n        displayAlreadyInitializedError('KUBESENSE_LOGS', initConfiguration)\n        return\n      }\n\n      callPluginsMethod(initConfiguration.plugins, 'onInit', {\n        initConfiguration,\n        publicApi,\n        registerAssembleEventHook: hooks.assembleEvent.register,\n      })\n\n      const configuration = validateAndBuildLogsConfiguration(initConfiguration)\n      if (!configuration || !isAllowedTrackingOrigins(configuration, errorStack ?? '')) {\n        refreshRemoteSdkConfiguration()\n        return\n      }\n\n      cachedConfiguration = configuration\n\n      trackingConsentState.tryToInit(configuration.trackingConsent)\n\n      trackingConsentState.onGrantedOnce(() => {\n        startTrackingConsentContext(hooks, trackingConsentState)\n        mockable(startTelemetry)(TelemetryService.LOGS, configuration, hooks.assembleTelemetry, sdkName)\n        const sessionManagerPromise = canUseEventBridge()\n          ? startSessionManagerStub()\n          : mockable(startSessionManager)(configuration, trackingConsentState)\n\n        void sessionManagerPromise\n          .then((newSessionManager) => {\n            if (!newSessionManager) {\n              return\n            }\n            sessionManager = newSessionManager\n            startTelemetrySessionContext(hooks.assembleTelemetry, sessionManager)\n            addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration))\n            tryStartLogs()\n\n            // Fire-and-forget, after the SDK is running: refreshes the cache for the next page load.\n            refreshRemoteSdkConfiguration()\n          })\n          .catch(monitorError)\n      })\n    },\n\n    get initConfiguration() {\n      return cachedInitConfiguration\n    },\n\n    globalContext,\n    accountContext,\n    userContext,\n\n    getInternalContext: noop as () => undefined,\n\n    handleLog(message, statusType, handlingStack, context = getCommonContext(), date = timeStampNow()) {\n      bufferApiCalls.notify((startLogsResult) =>\n        startLogsResult.handleLog(message, statusType, handlingStack, context, date)\n      )\n    },\n  }\n}\n\nfunction overrideInitConfigurationForBridge(initConfiguration: LogsInitConfiguration): LogsInitConfiguration {\n  return { ...initConfiguration, clientToken: 'empty' }\n}\n"],"mappings":";;;;;;;;;AA2CA,SAAgB,uBACd,kBACA,sBACA,aACA,SACU;CAEV,MAAM,iBAAiB,IAAI,mBAA+D,MAAe,UAAU;EAEjH,kBAAkB,iCAAiC,EAAE,MAAM,CAAC;CAC9D,CAAC;CAGD,MAAM,gBAAgB,0BAA0B;CAChD,mBAAmB,eAAe,mBAAmB,eAAe,cAAc;CAElF,MAAM,iBAAiB,2BAA2B;CAClD,mBAAmB,gBAAgB,mBAAmB,gBAAgB,cAAc;CAEpF,MAAM,cAAc,wBAAwB;CAC5C,mBAAmB,aAAa,mBAAmB,aAAa,cAAc;CAE9E,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,MAAM,QAAQ,YAAY;CAC1B,MAAM,mCAAmC,qBAAqB,WAAW,UAAU,YAAY;CAE/F,SAAS,eAAe;EACtB,IAAI,CAAC,uBAAuB,CAAC,2BAA2B,CAAC,gBACvD;EAGF,iCAAiC,YAAY;EAC7C,MAAM,kBAAkB,YAAY,qBAAqB,gBAAgB,KAAK;EAE9E,eAAe,WAAW,aAAa,SAAS,eAAe,CAAC;EAChE,eAAe,SAAS;CAC1B;CAEA,OAAO;EACL,KAAK,mBAAmB,WAAW,YAAY;GAC7C,IAAI,CAAC,mBAAmB;IACtB,QAAQ,MAAM,uBAAuB;IACrC;GACF;GAEA,iBAAiB,kBAAkB,0BAA0B;GAC7D,wBAAwB,kBAAkB,oBAAoB;GAE9D,IAAI,kBAAkB,GACpB,oBAAoB,mCAAmC,iBAAiB;GAG1E,MAAM,gCAAgC,CAAC,CAAC,kBAAkB;GAK1D,MAAM,sCAAsC;IAC1C,IAAI,+BACF,oCAAoC,iBAAiB,CAAC,CAAC,MAAM,IAAI;GAErE;GAEA,IAAI,+BAA+B;IAGjC,MAAM,yBAAyB,gCAAgC,iBAAiB;IAChF,oBAAoB,uBAAuB;IAE3C,IAAI,CAAC,uBAAuB,aAAa;KAGvC,0BAA0B;KAC1B,8BAA8B;KAC9B;IACF;GACF;GAGA,0BAA0B;GAE1B,IAAI,qBAAqB;IACvB,+BAA+B,kBAAkB,iBAAiB;IAClE;GACF;GAEA,kBAAkB,kBAAkB,SAAS,UAAU;IACrD;IACA;IACA,2BAA2B,MAAM,cAAc;GACjD,CAAC;GAED,MAAM,gBAAgB,kCAAkC,iBAAiB;GACzE,IAAI,CAAC,iBAAiB,CAAC,yBAAyB,eAAe,cAAc,EAAE,GAAG;IAChF,8BAA8B;IAC9B;GACF;GAEA,sBAAsB;GAEtB,qBAAqB,UAAU,cAAc,eAAe;GAE5D,qBAAqB,oBAAoB;IACvC,4BAA4B,OAAO,oBAAoB;IACvD,SAAS,cAAc,CAAC,CAAC,iBAAiB,MAAM,eAAe,MAAM,mBAAmB,OAAO;IAK/F,CAJ8B,kBAAkB,IAC5C,wBAAwB,IACxB,SAAS,mBAAmB,CAAC,CAAC,eAAe,oBAAoB,EAAA,CAGlE,MAAM,sBAAsB;KAC3B,IAAI,CAAC,mBACH;KAEF,iBAAiB;KACjB,6BAA6B,MAAM,mBAAmB,cAAc;KACpE,0BAA0B,2BAA2B,iBAAiB,CAAC;KACvE,aAAa;KAGb,8BAA8B;IAChC,CAAC,CAAC,CACD,MAAM,YAAY;GACvB,CAAC;EACH;EAEA,IAAI,oBAAoB;GACtB,OAAO;EACT;EAEA;EACA;EACA;EAEA,oBAAoB;EAEpB,UAAU,SAAS,YAAY,eAAe,UAAU,iBAAiB,GAAG,OAAO,aAAa,GAAG;GACjG,eAAe,QAAQ,oBACrB,gBAAgB,UAAU,SAAS,YAAY,eAAe,SAAS,IAAI,CAC7E;EACF;CACF;AACF;AAEA,SAAS,mCAAmC,mBAAiE;CAC3G,OAAO;EAAE,GAAG;EAAmB,aAAa;CAAQ;AACtD"}

package/esm/boot/startLogs.mjs

@@ -0,0 +1,54 @@
+import { LifeCycle } from "../domain/lifeCycle.mjs";
+import { startLogsAssembly } from "../domain/assembly.mjs";
+import { startConsoleCollection } from "../domain/console/consoleCollection.mjs";
+import { startReportCollection } from "../domain/report/reportCollection.mjs";
+import { startNetworkErrorCollection } from "../domain/networkError/networkErrorCollection.mjs";
+import { startRuntimeErrorCollection } from "../domain/runtimeError/runtimeErrorCollection.mjs";
+import { startLoggerCollection } from "../domain/logger/loggerCollection.mjs";
+import { startLogsBatch } from "../transport/startLogsBatch.mjs";
+import { startLogsBridge } from "../transport/startLogsBridge.mjs";
+import { startInternalContext } from "../domain/contexts/internalContext.mjs";
+import { startReportError } from "../domain/reportError.mjs";
+import { startRUMInternalContext } from "../domain/contexts/rumInternalContext.mjs";
+import { startSessionContext } from "../domain/contexts/sessionContext.mjs";
+import { canUseEventBridge, sendToExtension, startAccountContext, startGlobalContext, startTabContext, startUserContext } from "@kubesense/kubesense-browser-core";
+//#region src/boot/startLogs.ts
+const LOGS_STORAGE_KEY = "logs";
+function startLogs(configuration, sessionManager, getCommonContext, bufferedDataObservable, hooks) {
+	const lifeCycle = new LifeCycle();
+	const cleanupTasks = [];
+	lifeCycle.subscribe(1, (log) => sendToExtension("logs", log));
+	const reportError = startReportError(lifeCycle);
+	const { assembleEventDefaults: assembleHook } = hooks;
+	startSessionContext(assembleHook, configuration, sessionManager);
+	const accountContext = startAccountContext(assembleHook, configuration, LOGS_STORAGE_KEY);
+	const userContext = startUserContext(assembleHook, configuration, sessionManager, LOGS_STORAGE_KEY);
+	const globalContext = startGlobalContext(assembleHook, configuration, LOGS_STORAGE_KEY, false);
+	startRUMInternalContext(hooks);
+	startTabContext(assembleHook);
+	startNetworkErrorCollection(configuration, lifeCycle, bufferedDataObservable);
+	startRuntimeErrorCollection(configuration, lifeCycle, bufferedDataObservable);
+	startConsoleCollection(configuration, lifeCycle, bufferedDataObservable);
+	bufferedDataObservable.unbuffer();
+	startReportCollection(configuration, lifeCycle);
+	const { handleLog } = startLoggerCollection(lifeCycle);
+	startLogsAssembly(configuration, lifeCycle, hooks, getCommonContext, reportError);
+	if (!canUseEventBridge()) {
+		const { stop: stopLogsBatch } = startLogsBatch(configuration, lifeCycle, reportError, sessionManager);
+		cleanupTasks.push(() => stopLogsBatch());
+	} else startLogsBridge(lifeCycle);
+	return {
+		handleLog,
+		getInternalContext: startInternalContext(sessionManager).get,
+		accountContext,
+		globalContext,
+		userContext,
+		stop: () => {
+			cleanupTasks.forEach((task) => task());
+		}
+	};
+}
+//#endregion
+export { startLogs };
+
+//# sourceMappingURL=startLogs.mjs.map

package/esm/boot/startLogs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"startLogs.mjs","names":[],"sources":["../../src/boot/startLogs.ts"],"sourcesContent":["import type { BufferedObservable, BufferedData, SessionManager } from '@kubesense/kubesense-browser-core'\nimport {\n  sendToExtension,\n  canUseEventBridge,\n  startAccountContext,\n  startGlobalContext,\n  startUserContext,\n  startTabContext,\n} from '@kubesense/kubesense-browser-core'\nimport type { LogsConfiguration } from '../domain/configuration'\nimport { startLogsAssembly } from '../domain/assembly'\nimport { startConsoleCollection } from '../domain/console/consoleCollection'\nimport { startReportCollection } from '../domain/report/reportCollection'\nimport { startNetworkErrorCollection } from '../domain/networkError/networkErrorCollection'\nimport { startRuntimeErrorCollection } from '../domain/runtimeError/runtimeErrorCollection'\nimport { LifeCycle, LifeCycleEventType } from '../domain/lifeCycle'\nimport { startLoggerCollection } from '../domain/logger/loggerCollection'\nimport { startLogsBatch } from '../transport/startLogsBatch'\nimport { startLogsBridge } from '../transport/startLogsBridge'\nimport { startInternalContext } from '../domain/contexts/internalContext'\nimport { startReportError } from '../domain/reportError'\nimport type { CommonContext } from '../rawLogsEvent.types'\nimport type { Hooks } from '../domain/hooks'\nimport { startRUMInternalContext } from '../domain/contexts/rumInternalContext'\nimport { startSessionContext } from '../domain/contexts/sessionContext'\n\nconst LOGS_STORAGE_KEY = 'logs'\n\nexport type StartLogs = typeof startLogs\nexport type StartLogsResult = ReturnType<StartLogs>\n\nexport function startLogs(\n  configuration: LogsConfiguration,\n  sessionManager: SessionManager,\n  getCommonContext: () => CommonContext,\n  bufferedDataObservable: BufferedObservable<BufferedData>,\n  hooks: Hooks\n) {\n  const lifeCycle = new LifeCycle()\n  const cleanupTasks: Array<() => void> = []\n\n  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, (log) => sendToExtension('logs', log))\n\n  const reportError = startReportError(lifeCycle)\n\n  // Start user and account context first to allow overrides from global context\n  const { assembleEventDefaults: assembleHook } = hooks\n  startSessionContext(assembleHook, configuration, sessionManager)\n  const accountContext = startAccountContext(assembleHook, configuration, LOGS_STORAGE_KEY)\n  const userContext = startUserContext(assembleHook, configuration, sessionManager, LOGS_STORAGE_KEY)\n  const globalContext = startGlobalContext(assembleHook, configuration, LOGS_STORAGE_KEY, false)\n  startRUMInternalContext(hooks)\n  startTabContext(assembleHook)\n\n  startNetworkErrorCollection(configuration, lifeCycle, bufferedDataObservable)\n  startRuntimeErrorCollection(configuration, lifeCycle, bufferedDataObservable)\n  startConsoleCollection(configuration, lifeCycle, bufferedDataObservable)\n  bufferedDataObservable.unbuffer()\n  startReportCollection(configuration, lifeCycle)\n  const { handleLog } = startLoggerCollection(lifeCycle)\n\n  startLogsAssembly(configuration, lifeCycle, hooks, getCommonContext, reportError)\n\n  if (!canUseEventBridge()) {\n    const { stop: stopLogsBatch } = startLogsBatch(configuration, lifeCycle, reportError, sessionManager)\n    cleanupTasks.push(() => stopLogsBatch())\n  } else {\n    startLogsBridge(lifeCycle)\n  }\n\n  const internalContext = startInternalContext(sessionManager)\n\n  return {\n    handleLog,\n    getInternalContext: internalContext.get,\n    accountContext,\n    globalContext,\n    userContext,\n    stop: () => {\n      cleanupTasks.forEach((task) => task())\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA0BA,MAAM,mBAAmB;AAKzB,SAAgB,UACd,eACA,gBACA,kBACA,wBACA,OACA;CACA,MAAM,YAAY,IAAI,UAAU;CAChC,MAAM,eAAkC,CAAC;CAEzC,UAAU,UAAA,IAA6C,QAAQ,gBAAgB,QAAQ,GAAG,CAAC;CAE3F,MAAM,cAAc,iBAAiB,SAAS;CAG9C,MAAM,EAAE,uBAAuB,iBAAiB;CAChD,oBAAoB,cAAc,eAAe,cAAc;CAC/D,MAAM,iBAAiB,oBAAoB,cAAc,eAAe,gBAAgB;CACxF,MAAM,cAAc,iBAAiB,cAAc,eAAe,gBAAgB,gBAAgB;CAClG,MAAM,gBAAgB,mBAAmB,cAAc,eAAe,kBAAkB,KAAK;CAC7F,wBAAwB,KAAK;CAC7B,gBAAgB,YAAY;CAE5B,4BAA4B,eAAe,WAAW,sBAAsB;CAC5E,4BAA4B,eAAe,WAAW,sBAAsB;CAC5E,uBAAuB,eAAe,WAAW,sBAAsB;CACvE,uBAAuB,SAAS;CAChC,sBAAsB,eAAe,SAAS;CAC9C,MAAM,EAAE,cAAc,sBAAsB,SAAS;CAErD,kBAAkB,eAAe,WAAW,OAAO,kBAAkB,WAAW;CAEhF,IAAI,CAAC,kBAAkB,GAAG;EACxB,MAAM,EAAE,MAAM,kBAAkB,eAAe,eAAe,WAAW,aAAa,cAAc;EACpG,aAAa,WAAW,cAAc,CAAC;CACzC,OACE,gBAAgB,SAAS;CAK3B,OAAO;EACL;EACA,oBAJsB,qBAAqB,cAIT,CAAC,CAAC;EACpC;EACA;EACA;EACA,YAAY;GACV,aAAa,SAAS,SAAS,KAAK,CAAC;EACvC;CACF;AACF"}

package/esm/domain/assembly.mjs

@@ -0,0 +1,35 @@
+import { STATUSES } from "./logger.mjs";
+import "./lifeCycle.mjs";
+import { combine } from "@kubesense/kubesense-js-core/util";
+import { ErrorSource, buildTags, createEventRateLimiter } from "@kubesense/kubesense-browser-core";
+import { toRelativeTime } from "@kubesense/kubesense-js-core/time";
+import { DISCARDED } from "@kubesense/kubesense-js-core/assembly";
+//#region src/domain/assembly.ts
+function startLogsAssembly(configuration, lifeCycle, hooks, getCommonContext, reportError, eventRateLimit) {
+	const statusWithCustom = STATUSES.concat(["custom"]);
+	const logRateLimiters = {};
+	statusWithCustom.forEach((status) => {
+		logRateLimiters[status] = createEventRateLimiter(status, reportError, eventRateLimit);
+	});
+	lifeCycle.subscribe(0, ({ rawLogsEvent, savedCommonContext = void 0, domainContext, ktags = [] }) => {
+		const startTime = toRelativeTime(rawLogsEvent.date);
+		const commonContext = savedCommonContext || getCommonContext();
+		const assemblyParams = {
+			startTime,
+			rawLogsEvent,
+			domainContext
+		};
+		const defaultLogsEventAttributes = hooks.assembleEventDefaults.trigger(assemblyParams);
+		if (defaultLogsEventAttributes === DISCARDED) return;
+		const logsEventAttributes = hooks.assembleEvent.trigger(assemblyParams);
+		if (logsEventAttributes === DISCARDED) return;
+		const defaultKtags = buildTags(configuration);
+		const log = combine({ view: commonContext.view }, defaultLogsEventAttributes, rawLogsEvent, logsEventAttributes, { ktags: defaultKtags.concat(ktags).join(",") });
+		if (configuration.beforeSend?.(log, domainContext) === false || log.origin !== ErrorSource.AGENT && (logRateLimiters[log.status] ?? logRateLimiters["custom"]).isLimitReached()) return;
+		lifeCycle.notify(1, log);
+	});
+}
+//#endregion
+export { startLogsAssembly };
+
+//# sourceMappingURL=assembly.mjs.map

package/esm/domain/assembly.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly.mjs","names":[],"sources":["../../src/domain/assembly.ts"],"sourcesContent":["import type { Context, EventRateLimiter } from '@kubesense/kubesense-browser-core'\nimport { ErrorSource, buildTags, createEventRateLimiter } from '@kubesense/kubesense-browser-core'\nimport { toRelativeTime } from '@kubesense/kubesense-js-core/time'\nimport { DISCARDED } from '@kubesense/kubesense-js-core/assembly'\nimport { combine } from '@kubesense/kubesense-js-core/util'\nimport type { CommonContext } from '../rawLogsEvent.types'\nimport type { LogsEvent } from '../logsEvent.types'\nimport type { LogsConfiguration } from './configuration'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\nimport { STATUSES } from './logger'\nimport type { Hooks, AssembleHookParams } from './hooks'\n\nexport function startLogsAssembly(\n  configuration: LogsConfiguration,\n  lifeCycle: LifeCycle,\n  hooks: Hooks,\n  getCommonContext: () => CommonContext,\n  reportError: (message: string) => void,\n  eventRateLimit?: number\n) {\n  const statusWithCustom = (STATUSES as string[]).concat(['custom'])\n  const logRateLimiters: { [key: string]: EventRateLimiter } = {}\n  statusWithCustom.forEach((status) => {\n    logRateLimiters[status] = createEventRateLimiter(status, reportError, eventRateLimit)\n  })\n\n  lifeCycle.subscribe(\n    LifeCycleEventType.RAW_LOG_COLLECTED,\n    ({ rawLogsEvent, savedCommonContext = undefined, domainContext, ktags = [] }) => {\n      const startTime = toRelativeTime(rawLogsEvent.date)\n      const commonContext = savedCommonContext || getCommonContext()\n      const assemblyParams: AssembleHookParams = {\n        startTime,\n        rawLogsEvent: rawLogsEvent as AssembleHookParams['rawLogsEvent'],\n        domainContext,\n      }\n      const defaultLogsEventAttributes = hooks.assembleEventDefaults.trigger(assemblyParams)\n      if (defaultLogsEventAttributes === DISCARDED) {\n        return\n      }\n\n      const logsEventAttributes = hooks.assembleEvent.trigger(assemblyParams)!\n      if (logsEventAttributes === DISCARDED) {\n        return\n      }\n\n      const defaultKtags = buildTags(configuration)\n\n      const log = combine(\n        {\n          view: commonContext.view,\n        },\n        defaultLogsEventAttributes,\n        rawLogsEvent,\n        logsEventAttributes,\n        {\n          ktags: defaultKtags.concat(ktags).join(','),\n        }\n      ) as LogsEvent & Context\n\n      if (\n        configuration.beforeSend?.(log, domainContext) === false ||\n        (log.origin !== ErrorSource.AGENT &&\n          (logRateLimiters[log.status] ?? logRateLimiters['custom']).isLimitReached())\n      ) {\n        return\n      }\n\n      lifeCycle.notify(LifeCycleEventType.LOG_COLLECTED, log)\n    }\n  )\n}\n"],"mappings":";;;;;;;AAaA,SAAgB,kBACd,eACA,WACA,OACA,kBACA,aACA,gBACA;CACA,MAAM,mBAAoB,SAAsB,OAAO,CAAC,QAAQ,CAAC;CACjE,MAAM,kBAAuD,CAAC;CAC9D,iBAAiB,SAAS,WAAW;EACnC,gBAAgB,UAAU,uBAAuB,QAAQ,aAAa,cAAc;CACtF,CAAC;CAED,UAAU,UAAA,IAEP,EAAE,cAAc,qBAAqB,KAAA,GAAW,eAAe,QAAQ,CAAC,QAAQ;EAC/E,MAAM,YAAY,eAAe,aAAa,IAAI;EAClD,MAAM,gBAAgB,sBAAsB,iBAAiB;EAC7D,MAAM,iBAAqC;GACzC;GACc;GACd;EACF;EACA,MAAM,6BAA6B,MAAM,sBAAsB,QAAQ,cAAc;EACrF,IAAI,+BAA+B,WACjC;EAGF,MAAM,sBAAsB,MAAM,cAAc,QAAQ,cAAc;EACtE,IAAI,wBAAwB,WAC1B;EAGF,MAAM,eAAe,UAAU,aAAa;EAE5C,MAAM,MAAM,QACV,EACE,MAAM,cAAc,KACtB,GACA,4BACA,cACA,qBACA,EACE,OAAO,aAAa,OAAO,KAAK,CAAC,CAAC,KAAK,GAAG,EAC5C,CACF;EAEA,IACE,cAAc,aAAa,KAAK,aAAa,MAAM,SAClD,IAAI,WAAW,YAAY,UACzB,gBAAgB,IAAI,WAAW,gBAAgB,UAAA,CAAW,eAAe,GAE5E;EAGF,UAAU,OAAA,GAAyC,GAAG;CACxD,CACF;AACF"}

package/esm/domain/configuration.mjs

@@ -0,0 +1,84 @@
+import { ConsoleApiName } from "@kubesense/kubesense-js-core/util";
+import { BROWSER_CORE_SCHEMA, RawReportType, catchUserErrors, display, serializeConfiguration } from "@kubesense/kubesense-browser-core";
+import { validateAndBuildConfiguration } from "@kubesense/kubesense-js-core/configuration";
+//#region src/domain/configuration.ts
+const LOGS_SCHEMA = {
+	...BROWSER_CORE_SCHEMA,
+	forwardErrorsToLogs: {
+		type: "boolean",
+		default: true,
+		strict: false
+	},
+	enableRemoteSdkConfiguration: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	forwardConsoleLogs: {
+		type: "enum",
+		values: ConsoleApiName,
+		multiple: true,
+		allowAll: true,
+		default: []
+	},
+	forwardReports: {
+		type: "enum",
+		values: RawReportType,
+		multiple: true,
+		allowAll: true,
+		default: []
+	},
+	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
+			},
+			onLogsStart: {
+				type: "function",
+				strict: false,
+				signature: void 0
+			}
+		}
+	}
+};
+function validateAndBuildLogsConfiguration(initConfiguration) {
+	const config = validateAndBuildConfiguration(initConfiguration, LOGS_SCHEMA, display);
+	if (!config) return;
+	return {
+		...config,
+		beforeSend: config.beforeSend ? catchUserErrors(config.beforeSend, "beforeSend threw an error:") : void 0
+	};
+}
+function serializeLogsConfiguration(configuration) {
+	const baseSerializedInitConfiguration = serializeConfiguration(configuration);
+	return {
+		forward_errors_to_logs: configuration.forwardErrorsToLogs,
+		enable_remote_sdk_configuration: !!configuration.enableRemoteSdkConfiguration,
+		forward_console_logs: configuration.forwardConsoleLogs,
+		forward_reports: configuration.forwardReports,
+		plugins: configuration.plugins?.map((plugin) => ({
+			name: plugin.name,
+			...plugin.getConfigurationTelemetry?.()
+		})),
+		...baseSerializedInitConfiguration
+	};
+}
+//#endregion
+export { LOGS_SCHEMA, serializeLogsConfiguration, validateAndBuildLogsConfiguration };
+
+//# sourceMappingURL=configuration.mjs.map

package/esm/domain/configuration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.mjs","names":[],"sources":["../../src/domain/configuration.ts"],"sourcesContent":["import type { InitConfiguration, RawTelemetryConfiguration } from '@kubesense/kubesense-browser-core'\nimport { ConsoleApiName } from '@kubesense/kubesense-js-core/util'\nimport {\n  serializeConfiguration,\n  catchUserErrors,\n  display,\n  RawReportType,\n  BROWSER_CORE_SCHEMA,\n} from '@kubesense/kubesense-browser-core'\nimport { validateAndBuildConfiguration } from '@kubesense/kubesense-js-core/configuration'\nimport type { InferredConfig } from '@kubesense/kubesense-js-core/configuration'\nimport type { LogsEvent } from '../logsEvent.types'\nimport type { LogsEventDomainContext } from '../domainContext.types'\nimport type { LogsPlugin } from './plugins'\n\n/**\n * Init Configuration for the Logs browser SDK.\n *\n * @category Main\n * @example NPM\n * ```ts\n * import { kubesenseLogs } from '@kubesense/kubesense-browser-logs'\n *\n * kubesenseLogs.init({\n *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',\n *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',\n *   // ...\n * })\n * ```\n * @example CDN\n * ```ts\n * KUBESENSE_LOGS.init({\n *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',\n *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',\n *   // ...\n * })\n * ```\n */\nexport interface LogsInitConfiguration extends InitConfiguration {\n  /**\n   * Access to every logs collected by the Logs SDK before they are sent to KubeSense.\n   * It allows:\n   * - Enrich your logs with additional context attributes\n   * - Modify your logs to modify their content, or redact sensitive sequences (see the list of editable properties)\n   * - Discard selected logs\n   *\n   * @category Data Collection\n   */\n  beforeSend?: LogsBeforeSend | undefined\n\n  /**\n   * Forward uncaught exceptions and network errors to KubeSense.\n   *\n   * To capture `console.error` calls, use {@link forwardConsoleLogs} with `\"error\"` (or `\"all\"`).\n   *\n   * @category Data Collection\n   * @defaultValue true\n   * @see forwardConsoleLogs\n   */\n  forwardErrorsToLogs?: boolean | undefined\n\n  /**\n   * Forward logs from console.* to KubeSense. Use \"all\" to forward everything or an array of console API names to forward only a subset.\n   *\n   * @category Data Collection\n   */\n  forwardConsoleLogs?: ConsoleApiName[] | 'all' | undefined\n\n  /**\n   * Forward reports from the [Reporting API](https://developer.mozilla.org/en-US/docs/Web/API/Reporting_API) to KubeSense. Use \"all\" to forward everything or an array of report types to forward only a subset.\n   *\n   * @category Data Collection\n   */\n  forwardReports?: RawReportType[] | 'all' | undefined\n\n  /**\n   * List of plugins to enable. The plugins API is unstable and experimental, and may change without\n   * notice. Please use only plugins provided by KubeSense matching the version of the SDK you are\n   * using.\n   *\n   * @experimental\n   */\n  plugins?: LogsPlugin[] | undefined\n\n  /**\n   * Enable dashboard-managed SDK settings served by the KubeSense collector.\n   *\n   * Logs reads the same cached document as RUM, but only consumes the `features.logs` switch and\n   * the `logs` section. The document is fetched asynchronously after the SDK starts, so it never\n   * delays initialization, and cached settings are applied on the next page load.\n   *\n   * @category Data Collection\n   * @defaultValue false\n   */\n  enableRemoteSdkConfiguration?: boolean | undefined\n}\n\n/**\n * Function called before a Log event is sent to KubeSense. See {@link LogsInitConfiguration.beforeSend}\n *\n * @param event - The log event\n * @param context - The log event domain context\n * @returns true if the event should be sent to KubeSense, false otherwise\n */\nexport type LogsBeforeSend = (event: LogsEvent, context: LogsEventDomainContext) => boolean\n\nexport const LOGS_SCHEMA = {\n  ...BROWSER_CORE_SCHEMA,\n  forwardErrorsToLogs: { type: 'boolean', default: true, strict: false },\n  enableRemoteSdkConfiguration: { type: 'boolean', default: false, strict: false },\n  forwardConsoleLogs: {\n    type: 'enum',\n    values: ConsoleApiName,\n    multiple: true,\n    allowAll: true,\n    default: [] as ConsoleApiName[],\n  },\n  forwardReports: {\n    type: 'enum',\n    values: RawReportType,\n    multiple: true,\n    allowAll: true,\n    default: [] as RawReportType[],\n  },\n  plugins: {\n    type: 'schema',\n    multiple: true,\n    strict: false,\n    default: [] as LogsPlugin[],\n    schema: {\n      name: { type: 'string', required: true },\n      getConfigurationTelemetry: {\n        type: 'function',\n        strict: false,\n        signature: undefined as LogsPlugin['getConfigurationTelemetry'],\n      },\n      onInit: { type: 'function', strict: false, signature: undefined as LogsPlugin['onInit'] },\n      onLogsStart: { type: 'function', strict: false, signature: undefined as LogsPlugin['onLogsStart'] },\n    },\n  },\n} as const\n\nexport type LogsConfiguration = InferredConfig<typeof LOGS_SCHEMA>\n\nexport function validateAndBuildLogsConfiguration(\n  initConfiguration: LogsInitConfiguration\n): LogsConfiguration | undefined {\n  const config = validateAndBuildConfiguration(\n    initConfiguration as unknown as Record<string, unknown>,\n    LOGS_SCHEMA,\n    display\n  )\n  if (!config) {\n    return\n  }\n  return {\n    ...config,\n    beforeSend: config.beforeSend ? catchUserErrors(config.beforeSend as any, 'beforeSend threw an error:') : undefined,\n  }\n}\n\nexport function serializeLogsConfiguration(configuration: LogsInitConfiguration) {\n  const baseSerializedInitConfiguration = serializeConfiguration(configuration)\n\n  return {\n    forward_errors_to_logs: configuration.forwardErrorsToLogs,\n    enable_remote_sdk_configuration: !!configuration.enableRemoteSdkConfiguration,\n    forward_console_logs: configuration.forwardConsoleLogs,\n    forward_reports: configuration.forwardReports,\n    plugins: configuration.plugins?.map((plugin) => ({\n      name: plugin.name,\n      ...plugin.getConfigurationTelemetry?.(),\n    })),\n    ...baseSerializedInitConfiguration,\n  } satisfies RawTelemetryConfiguration\n}\n"],"mappings":";;;;AA0GA,MAAa,cAAc;CACzB,GAAG;CACH,qBAAqB;EAAE,MAAM;EAAW,SAAS;EAAM,QAAQ;CAAM;CACrE,8BAA8B;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CAC/E,oBAAoB;EAClB,MAAM;EACN,QAAQ;EACR,UAAU;EACV,UAAU;EACV,SAAS,CAAC;CACZ;CACA,gBAAgB;EACd,MAAM;EACN,QAAQ;EACR,UAAU;EACV,UAAU;EACV,SAAS,CAAC;CACZ;CACA,SAAS;EACP,MAAM;EACN,UAAU;EACV,QAAQ;EACR,SAAS,CAAC;EACV,QAAQ;GACN,MAAM;IAAE,MAAM;IAAU,UAAU;GAAK;GACvC,2BAA2B;IACzB,MAAM;IACN,QAAQ;IACR,WAAW,KAAA;GACb;GACA,QAAQ;IAAE,MAAM;IAAY,QAAQ;IAAO,WAAW,KAAA;GAAkC;GACxF,aAAa;IAAE,MAAM;IAAY,QAAQ;IAAO,WAAW,KAAA;GAAuC;EACpG;CACF;AACF;AAIA,SAAgB,kCACd,mBAC+B;CAC/B,MAAM,SAAS,8BACb,mBACA,aACA,OACF;CACA,IAAI,CAAC,QACH;CAEF,OAAO;EACL,GAAG;EACH,YAAY,OAAO,aAAa,gBAAgB,OAAO,YAAmB,4BAA4B,IAAI,KAAA;CAC5G;AACF;AAEA,SAAgB,2BAA2B,eAAsC;CAC/E,MAAM,kCAAkC,uBAAuB,aAAa;CAE5E,OAAO;EACL,wBAAwB,cAAc;EACtC,iCAAiC,CAAC,CAAC,cAAc;EACjD,sBAAsB,cAAc;EACpC,iBAAiB,cAAc;EAC/B,SAAS,cAAc,SAAS,KAAK,YAAY;GAC/C,MAAM,OAAO;GACb,GAAG,OAAO,4BAA4B;EACxC,EAAE;EACF,GAAG;CACL;AACF"}

package/esm/domain/console/consoleCollection.mjs

@@ -0,0 +1,36 @@
+import { StatusType } from "../logger/isAuthorized.mjs";
+import { createErrorFieldFromRawError } from "../createErrorFieldFromRawError.mjs";
+import "../lifeCycle.mjs";
+import { ConsoleApiName, combine } from "@kubesense/kubesense-js-core/util";
+import { BufferedDataType, ErrorSource } from "@kubesense/kubesense-browser-core";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/console/consoleCollection.ts
+const LogStatusForApi = {
+	[ConsoleApiName.log]: StatusType.info,
+	[ConsoleApiName.debug]: StatusType.debug,
+	[ConsoleApiName.info]: StatusType.info,
+	[ConsoleApiName.warn]: StatusType.warn,
+	[ConsoleApiName.error]: StatusType.error
+};
+function startConsoleCollection(configuration, lifeCycle, bufferedDataObservable) {
+	const subscription = bufferedDataObservable.subscribe(({ data: log, type }) => {
+		if (type !== BufferedDataType.CONSOLE || !configuration.forwardConsoleLogs.includes(log.api)) return;
+		const collectedData = {
+			rawLogsEvent: combine({
+				date: timeStampNow(),
+				message: log.message,
+				origin: ErrorSource.CONSOLE,
+				error: log.error && createErrorFieldFromRawError(log.error),
+				_kubesense: log.error && { debug_ids: log.error.debugIds },
+				status: LogStatusForApi[log.api]
+			}, log.error?.context),
+			domainContext: { handlingStack: log.handlingStack }
+		};
+		lifeCycle.notify(0, collectedData);
+	});
+	return { stop: () => subscription.unsubscribe() };
+}
+//#endregion
+export { LogStatusForApi, startConsoleCollection };
+
+//# sourceMappingURL=consoleCollection.mjs.map

package/esm/domain/console/consoleCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleCollection.mjs","names":[],"sources":["../../../src/domain/console/consoleCollection.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { combine, ConsoleApiName } from '@kubesense/kubesense-js-core/util'\nimport type { Context, Observable, BufferedData } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport { BufferedDataType, ErrorSource } from '@kubesense/kubesense-browser-core'\nimport type { LogsConfiguration } from '../configuration'\nimport type { LifeCycle, RawLogsEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { StatusType } from '../logger/isAuthorized'\nimport type { RawLogsEvent } from '../../rawLogsEvent.types'\nimport { createErrorFieldFromRawError } from '../createErrorFieldFromRawError'\n\nexport interface ProvidedError {\n  startClocks: ClocksState\n  error: unknown\n  context?: Context\n  handlingStack: string\n}\n\nexport const LogStatusForApi = {\n  [ConsoleApiName.log]: StatusType.info,\n  [ConsoleApiName.debug]: StatusType.debug,\n  [ConsoleApiName.info]: StatusType.info,\n  [ConsoleApiName.warn]: StatusType.warn,\n  [ConsoleApiName.error]: StatusType.error,\n}\n\nexport function startConsoleCollection(\n  configuration: LogsConfiguration,\n  lifeCycle: LifeCycle,\n  bufferedDataObservable: Observable<BufferedData>\n) {\n  const subscription = bufferedDataObservable.subscribe(({ data: log, type }) => {\n    if (type !== BufferedDataType.CONSOLE || !configuration.forwardConsoleLogs.includes(log.api)) {\n      return\n    }\n    const collectedData: RawLogsEventCollectedData<RawLogsEvent> = {\n      rawLogsEvent: combine(\n        {\n          date: timeStampNow(),\n          message: log.message,\n          origin: ErrorSource.CONSOLE,\n          error: log.error && createErrorFieldFromRawError(log.error),\n          _kubesense: log.error && { debug_ids: log.error.debugIds },\n          status: LogStatusForApi[log.api],\n        },\n        log.error?.context\n      ),\n      domainContext: {\n        handlingStack: log.handlingStack,\n      },\n    }\n\n    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, collectedData)\n  })\n\n  return { stop: () => subscription.unsubscribe() }\n}\n"],"mappings":";;;;;;;AAmBA,MAAa,kBAAkB;EAC5B,eAAe,MAAM,WAAW;EAChC,eAAe,QAAQ,WAAW;EAClC,eAAe,OAAO,WAAW;EACjC,eAAe,OAAO,WAAW;EACjC,eAAe,QAAQ,WAAW;AACrC;AAEA,SAAgB,uBACd,eACA,WACA,wBACA;CACA,MAAM,eAAe,uBAAuB,WAAW,EAAE,MAAM,KAAK,WAAW;EAC7E,IAAI,SAAS,iBAAiB,WAAW,CAAC,cAAc,mBAAmB,SAAS,IAAI,GAAG,GACzF;EAEF,MAAM,gBAAyD;GAC7D,cAAc,QACZ;IACE,MAAM,aAAa;IACnB,SAAS,IAAI;IACb,QAAQ,YAAY;IACpB,OAAO,IAAI,SAAS,6BAA6B,IAAI,KAAK;IAC1D,YAAY,IAAI,SAAS,EAAE,WAAW,IAAI,MAAM,SAAS;IACzD,QAAQ,gBAAgB,IAAI;GAC9B,GACA,IAAI,OAAO,OACb;GACA,eAAe,EACb,eAAe,IAAI,cACrB;EACF;EAEA,UAAU,OAAA,GAA6C,aAAa;CACtE,CAAC;CAED,OAAO,EAAE,YAAY,aAAa,YAAY,EAAE;AAClD"}

package/esm/domain/contexts/commonContext.mjs

@@ -0,0 +1,13 @@
+import { isWorkerEnvironment } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/contexts/commonContext.ts
+function buildCommonContext() {
+	if (isWorkerEnvironment) return {};
+	return { view: {
+		referrer: document.referrer,
+		url: window.location.href
+	} };
+}
+//#endregion
+export { buildCommonContext };
+
+//# sourceMappingURL=commonContext.mjs.map

package/esm/domain/contexts/commonContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonContext.mjs","names":[],"sources":["../../../src/domain/contexts/commonContext.ts"],"sourcesContent":["import { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'\nimport type { CommonContext } from '../../rawLogsEvent.types'\n\nexport function buildCommonContext(): CommonContext {\n  if (isWorkerEnvironment) {\n    return {}\n  }\n\n  return {\n    view: {\n      referrer: document.referrer,\n      url: window.location.href,\n    },\n  }\n}\n"],"mappings":";;AAGA,SAAgB,qBAAoC;CAClD,IAAI,qBACF,OAAO,CAAC;CAGV,OAAO,EACL,MAAM;EACJ,UAAU,SAAS;EACnB,KAAK,OAAO,SAAS;CACvB,EACF;AACF"}

package/esm/domain/contexts/internalContext.mjs

@@ -0,0 +1,11 @@
+//#region src/domain/contexts/internalContext.ts
+function startInternalContext(sessionManager) {
+	return { get: (startTime) => {
+		const trackedSession = sessionManager.findTrackedSession(startTime);
+		if (trackedSession) return { session_id: trackedSession.id };
+	} };
+}
+//#endregion
+export { startInternalContext };
+
+//# sourceMappingURL=internalContext.mjs.map

package/esm/domain/contexts/internalContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalContext.mjs","names":[],"sources":["../../../src/domain/contexts/internalContext.ts"],"sourcesContent":["import type { RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport type { SessionManager } from '@kubesense/kubesense-browser-core'\n\nexport interface InternalContext {\n  session_id: string | undefined\n}\n\nexport function startInternalContext(sessionManager: SessionManager) {\n  return {\n    get: (startTime?: number): InternalContext | undefined => {\n      const trackedSession = sessionManager.findTrackedSession(startTime as RelativeTime)\n      if (trackedSession) {\n        return {\n          session_id: trackedSession.id,\n        }\n      }\n    },\n  }\n}\n"],"mappings":";AAOA,SAAgB,qBAAqB,gBAAgC;CACnE,OAAO,EACL,MAAM,cAAoD;EACxD,MAAM,iBAAiB,eAAe,mBAAmB,SAAyB;EAClF,IAAI,gBACF,OAAO,EACL,YAAY,eAAe,GAC7B;CAEJ,EACF;AACF"}

package/esm/domain/contexts/rumInternalContext.mjs

@@ -0,0 +1,32 @@
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+import { willSyntheticsInjectRum } from "@kubesense/kubesense-browser-core";
+import { SKIPPED } from "@kubesense/kubesense-js-core/assembly";
+//#region src/domain/contexts/rumInternalContext.ts
+function startRUMInternalContext(hooks) {
+	const browserWindow = globalObject;
+	hooks.assembleEventDefaults.register(({ startTime }) => {
+		const internalContext = getRUMInternalContext(startTime);
+		if (!internalContext) return SKIPPED;
+		return internalContext;
+	});
+	hooks.assembleTelemetry.register(({ startTime }) => {
+		const internalContext = getRUMInternalContext(startTime);
+		if (!internalContext) return SKIPPED;
+		return {
+			application: { id: internalContext.application_id },
+			view: { id: internalContext.view?.id },
+			action: { id: internalContext.user_action?.id }
+		};
+	});
+	function getRUMInternalContext(startTime) {
+		const rumContext = getInternalContextFromRumGlobal(startTime, willSyntheticsInjectRum() ? browserWindow.KUBESENSE_SDK_SYNTHETICS : browserWindow.KUBESENSE_SDK);
+		if (rumContext) return rumContext;
+	}
+	function getInternalContextFromRumGlobal(startTime, rumGlobal) {
+		if (rumGlobal?.getInternalContext) return rumGlobal.getInternalContext(startTime);
+	}
+}
+//#endregion
+export { startRUMInternalContext };
+
+//# sourceMappingURL=rumInternalContext.mjs.map

package/esm/domain/contexts/rumInternalContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rumInternalContext.mjs","names":[],"sources":["../../../src/domain/contexts/rumInternalContext.ts"],"sourcesContent":["import { globalObject } from '@kubesense/kubesense-js-core/util'\nimport type { RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport type { RumInternalContext } from '@kubesense/kubesense-browser-core'\nimport { willSyntheticsInjectRum } from '@kubesense/kubesense-browser-core'\nimport { SKIPPED } from '@kubesense/kubesense-js-core/assembly'\nimport type { Hooks } from '../hooks'\n\ninterface Rum {\n  getInternalContext?: (startTime?: RelativeTime) => RumInternalContext | undefined\n}\n\ninterface BrowserWindow {\n  KUBESENSE_SDK?: Rum\n  KUBESENSE_SDK_SYNTHETICS?: Rum\n}\n\nexport function startRUMInternalContext(hooks: Hooks) {\n  const browserWindow = globalObject as BrowserWindow\n\n  hooks.assembleEventDefaults.register(({ startTime }) => {\n    const internalContext = getRUMInternalContext(startTime)\n    if (!internalContext) {\n      return SKIPPED\n    }\n\n    return internalContext\n  })\n\n  hooks.assembleTelemetry.register(({ startTime }) => {\n    const internalContext = getRUMInternalContext(startTime)\n\n    if (!internalContext) {\n      return SKIPPED\n    }\n\n    return {\n      application: { id: internalContext.application_id },\n      view: { id: internalContext.view?.id },\n      action: { id: internalContext.user_action?.id as string },\n    }\n  })\n\n  function getRUMInternalContext(startTime?: RelativeTime) {\n    const willSyntheticsInjectRumResult = willSyntheticsInjectRum()\n    const rumSource = willSyntheticsInjectRumResult\n      ? browserWindow.KUBESENSE_SDK_SYNTHETICS\n      : browserWindow.KUBESENSE_SDK\n    const rumContext = getInternalContextFromRumGlobal(startTime, rumSource)\n\n    if (rumContext) {\n      return rumContext\n    }\n  }\n\n  function getInternalContextFromRumGlobal(startTime?: RelativeTime, rumGlobal?: Rum): RumInternalContext | undefined {\n    if (rumGlobal?.getInternalContext) {\n      return rumGlobal.getInternalContext(startTime)\n    }\n  }\n}\n"],"mappings":";;;;AAgBA,SAAgB,wBAAwB,OAAc;CACpD,MAAM,gBAAgB;CAEtB,MAAM,sBAAsB,UAAU,EAAE,gBAAgB;EACtD,MAAM,kBAAkB,sBAAsB,SAAS;EACvD,IAAI,CAAC,iBACH,OAAO;EAGT,OAAO;CACT,CAAC;CAED,MAAM,kBAAkB,UAAU,EAAE,gBAAgB;EAClD,MAAM,kBAAkB,sBAAsB,SAAS;EAEvD,IAAI,CAAC,iBACH,OAAO;EAGT,OAAO;GACL,aAAa,EAAE,IAAI,gBAAgB,eAAe;GAClD,MAAM,EAAE,IAAI,gBAAgB,MAAM,GAAG;GACrC,QAAQ,EAAE,IAAI,gBAAgB,aAAa,GAAa;EAC1D;CACF,CAAC;CAED,SAAS,sBAAsB,WAA0B;EAKvD,MAAM,aAAa,gCAAgC,WAJb,wBACQ,IAC1C,cAAc,2BACd,cAAc,aACqD;EAEvE,IAAI,YACF,OAAO;CAEX;CAEA,SAAS,gCAAgC,WAA0B,WAAiD;EAClH,IAAI,WAAW,oBACb,OAAO,UAAU,mBAAmB,SAAS;CAEjD;AACF"}

package/esm/domain/contexts/sessionContext.mjs

@@ -0,0 +1,20 @@
+import { DISCARDED } from "@kubesense/kubesense-js-core/assembly";
+//#region src/domain/contexts/sessionContext.ts
+function startSessionContext(hook, configuration, sessionManager) {
+	hook.register(({ startTime }) => {
+		const session = sessionManager.findTrackedSession(startTime);
+		if (!sessionManager.findTrackedSession(startTime, {
+			returnInactive: true,
+			maxAge: Infinity
+		})) return DISCARDED;
+		return {
+			service: configuration.service,
+			session_id: session ? session.id : void 0,
+			session: session ? { id: session.id } : void 0
+		};
+	});
+}
+//#endregion
+export { startSessionContext };
+
+//# sourceMappingURL=sessionContext.mjs.map

package/esm/domain/contexts/sessionContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionContext.mjs","names":[],"sources":["../../../src/domain/contexts/sessionContext.ts"],"sourcesContent":["import type { SessionManager } from '@kubesense/kubesense-browser-core'\nimport { DISCARDED } from '@kubesense/kubesense-js-core/assembly'\nimport type { LogsConfiguration } from '../configuration'\nimport type { AssembleHook } from '../hooks'\n\nexport function startSessionContext(\n  hook: AssembleHook,\n  configuration: LogsConfiguration,\n  sessionManager: SessionManager\n) {\n  hook.register(({ startTime }) => {\n    // Used to attach a (fresh, safe-to-reference) session id: subject to the default\n    // TRACKED_SESSION_MAX_AGE, so it becomes undefined once the session is too old to reference.\n    const session = sessionManager.findTrackedSession(startTime)\n\n    // Used for the discard decision: unlike `session` above, this ignores session age (logs\n    // should keep being sent indefinitely, with or without a session, once a session was\n    // legitimately tracked here) but still respects sampling.\n    const isSessionTracked = sessionManager.findTrackedSession(startTime, {\n      returnInactive: true,\n      maxAge: Infinity,\n    })\n\n    if (!isSessionTracked) {\n      return DISCARDED\n    }\n\n    return {\n      service: configuration.service,\n      session_id: session ? session.id : undefined,\n      session: session ? { id: session.id } : undefined,\n    }\n  })\n}\n"],"mappings":";;AAKA,SAAgB,oBACd,MACA,eACA,gBACA;CACA,KAAK,UAAU,EAAE,gBAAgB;EAG/B,MAAM,UAAU,eAAe,mBAAmB,SAAS;EAU3D,IAAI,CALqB,eAAe,mBAAmB,WAAW;GACpE,gBAAgB;GAChB,QAAQ;EACV,CAEoB,GAClB,OAAO;EAGT,OAAO;GACL,SAAS,cAAc;GACvB,YAAY,UAAU,QAAQ,KAAK,KAAA;GACnC,SAAS,UAAU,EAAE,IAAI,QAAQ,GAAG,IAAI,KAAA;EAC1C;CACF,CAAC;AACH"}

package/esm/domain/contexts/trackingConsentContext.mjs

@@ -0,0 +1,14 @@
+import { DISCARDED, SKIPPED } from "@kubesense/kubesense-js-core/assembly";
+//#region src/domain/contexts/trackingConsentContext.ts
+function startTrackingConsentContext(hooks, trackingConsentState) {
+	function isConsented() {
+		if (!trackingConsentState.isGranted()) return DISCARDED;
+		return SKIPPED;
+	}
+	hooks.assembleEventDefaults.register(isConsented);
+	hooks.assembleTelemetry.register(isConsented);
+}
+//#endregion
+export { startTrackingConsentContext };
+
+//# sourceMappingURL=trackingConsentContext.mjs.map