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

package/cjs/domain/assembly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly.js","names":["STATUSES","createEventRateLimiter","toRelativeTime","DISCARDED","buildTags","combine","ErrorSource"],"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,mBAAoBA,eAAAA,SAAsB,OAAO,CAAC,QAAQ,CAAC;CACjE,MAAM,kBAAuD,CAAC;CAC9D,iBAAiB,SAAS,WAAW;EACnC,gBAAgB,WAAA,GAAUC,kCAAAA,uBAAAA,CAAuB,QAAQ,aAAa,cAAc;CACtF,CAAC;CAED,UAAU,UAAA,IAEP,EAAE,cAAc,qBAAqB,KAAA,GAAW,eAAe,QAAQ,CAAC,QAAQ;EAC/E,MAAM,aAAA,GAAYC,kCAAAA,eAAAA,CAAe,aAAa,IAAI;EAClD,MAAM,gBAAgB,sBAAsB,iBAAiB;EAC7D,MAAM,iBAAqC;GACzC;GACc;GACd;EACF;EACA,MAAM,6BAA6B,MAAM,sBAAsB,QAAQ,cAAc;EACrF,IAAI,+BAA+BC,sCAAAA,WACjC;EAGF,MAAM,sBAAsB,MAAM,cAAc,QAAQ,cAAc;EACtE,IAAI,wBAAwBA,sCAAAA,WAC1B;EAGF,MAAM,gBAAA,GAAeC,kCAAAA,UAAAA,CAAU,aAAa;EAE5C,MAAM,OAAA,GAAMC,kCAAAA,QAAAA,CACV,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,WAAWC,kCAAAA,YAAY,UACzB,gBAAgB,IAAI,WAAW,gBAAgB,UAAA,CAAW,eAAe,GAE5E;EAGF,UAAU,OAAA,GAAyC,GAAG;CACxD,CACF;AACF"}

package/cjs/domain/configuration.d.ts

@@ -0,0 +1,306 @@
+import type { InitConfiguration } from '@kubesense/kubesense-browser-core';
+import { ConsoleApiName } from '@kubesense/kubesense-js-core/util';
+import { RawReportType } from '@kubesense/kubesense-browser-core';
+import type { InferredConfig } from '@kubesense/kubesense-js-core/configuration';
+import type { LogsEvent } from '../logsEvent.types';
+import type { LogsEventDomainContext } from '../domainContext.types';
+import type { LogsPlugin } from './plugins';
+/**
+ * Init Configuration for the Logs browser SDK.
+ *
+ * @category Main
+ * @example NPM
+ * ```ts
+ * import { kubesenseLogs } from '@kubesense/kubesense-browser-logs'
+ *
+ * kubesenseLogs.init({
+ *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',
+ *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',
+ *   // ...
+ * })
+ * ```
+ * @example CDN
+ * ```ts
+ * KUBESENSE_LOGS.init({
+ *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',
+ *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',
+ *   // ...
+ * })
+ * ```
+ */
+export interface LogsInitConfiguration extends InitConfiguration {
+    /**
+     * Access to every logs collected by the Logs SDK before they are sent to KubeSense.
+     * It allows:
+     * - Enrich your logs with additional context attributes
+     * - Modify your logs to modify their content, or redact sensitive sequences (see the list of editable properties)
+     * - Discard selected logs
+     *
+     * @category Data Collection
+     */
+    beforeSend?: LogsBeforeSend | undefined;
+    /**
+     * Forward uncaught exceptions and network errors to KubeSense.
+     *
+     * To capture `console.error` calls, use {@link forwardConsoleLogs} with `"error"` (or `"all"`).
+     *
+     * @category Data Collection
+     * @defaultValue true
+     * @see forwardConsoleLogs
+     */
+    forwardErrorsToLogs?: boolean | undefined;
+    /**
+     * Forward logs from console.* to KubeSense. Use "all" to forward everything or an array of console API names to forward only a subset.
+     *
+     * @category Data Collection
+     */
+    forwardConsoleLogs?: ConsoleApiName[] | 'all' | undefined;
+    /**
+     * 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.
+     *
+     * @category Data Collection
+     */
+    forwardReports?: RawReportType[] | 'all' | undefined;
+    /**
+     * List of plugins to enable. The plugins API is unstable and experimental, and may change without
+     * notice. Please use only plugins provided by KubeSense matching the version of the SDK you are
+     * using.
+     *
+     * @experimental
+     */
+    plugins?: LogsPlugin[] | undefined;
+    /**
+     * Enable dashboard-managed SDK settings served by the KubeSense collector.
+     *
+     * Logs reads the same cached document as RUM, but only consumes the `features.logs` switch and
+     * the `logs` section. The document is fetched asynchronously after the SDK starts, so it never
+     * delays initialization, and cached settings are applied on the next page load.
+     *
+     * @category Data Collection
+     * @defaultValue false
+     */
+    enableRemoteSdkConfiguration?: boolean | undefined;
+}
+/**
+ * Function called before a Log event is sent to KubeSense. See {@link LogsInitConfiguration.beforeSend}
+ *
+ * @param event - The log event
+ * @param context - The log event domain context
+ * @returns true if the event should be sent to KubeSense, false otherwise
+ */
+export type LogsBeforeSend = (event: LogsEvent, context: LogsEventDomainContext) => boolean;
+export declare const LOGS_SCHEMA: {
+    readonly forwardErrorsToLogs: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly strict: false;
+    };
+    readonly enableRemoteSdkConfiguration: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly forwardConsoleLogs: {
+        readonly type: "enum";
+        readonly values: {
+            readonly log: "log";
+            readonly debug: "debug";
+            readonly info: "info";
+            readonly warn: "warn";
+            readonly error: "error";
+        };
+        readonly multiple: true;
+        readonly allowAll: true;
+        readonly default: ConsoleApiName[];
+    };
+    readonly forwardReports: {
+        readonly type: "enum";
+        readonly values: {
+            readonly intervention: "intervention";
+            readonly deprecation: "deprecation";
+            readonly cspViolation: "csp_violation";
+        };
+        readonly multiple: true;
+        readonly allowAll: true;
+        readonly default: RawReportType[];
+    };
+    readonly plugins: {
+        readonly type: "schema";
+        readonly multiple: true;
+        readonly strict: false;
+        readonly default: LogsPlugin[];
+        readonly schema: {
+            readonly name: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly getConfigurationTelemetry: {
+                readonly type: "function";
+                readonly strict: false;
+                readonly signature: LogsPlugin["getConfigurationTelemetry"];
+            };
+            readonly onInit: {
+                readonly type: "function";
+                readonly strict: false;
+                readonly signature: LogsPlugin["onInit"];
+            };
+            readonly onLogsStart: {
+                readonly type: "function";
+                readonly strict: false;
+                readonly signature: LogsPlugin["onLogsStart"];
+            };
+        };
+    };
+    readonly clientToken: {
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly service: {
+        readonly type: "string";
+    };
+    readonly env: {
+        readonly type: "string";
+    };
+    readonly version: {
+        readonly type: "string";
+    };
+    readonly kubesenseRumEndpoint: {
+        readonly type: "site";
+        readonly default: string;
+    };
+    readonly proxy: {
+        readonly type: "union";
+        readonly variants: readonly [{
+            readonly type: "string";
+        }, {
+            readonly type: "function";
+            readonly signature: import("@kubesense/kubesense-js-core/transport").ProxyFn | undefined;
+        }];
+    };
+    readonly sessionSampleRate: {
+        readonly type: "percentage";
+        readonly default: 100;
+    };
+    readonly telemetrySampleRate: {
+        readonly type: "percentage";
+        readonly default: 20;
+    };
+    readonly telemetryConfigurationSampleRate: {
+        readonly type: "percentage";
+        readonly default: 5;
+    };
+    readonly telemetryUsageSampleRate: {
+        readonly type: "percentage";
+        readonly default: 5;
+    };
+    readonly silentMultipleInit: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly storeContextsAcrossPages: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly trackAnonymousUser: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly strict: false;
+    };
+    readonly useSecureSessionCookie: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly usePartitionedCrossSiteSessionCookie: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly trackSessionAcrossSubdomains: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly strict: false;
+    };
+    readonly allowedTrackingOrigins: {
+        readonly type: "match-option";
+        readonly multiple: true;
+        readonly strict: false;
+    };
+    readonly trackingConsent: {
+        readonly type: "enum";
+        readonly values: {
+            readonly GRANTED: "granted";
+            readonly NOT_GRANTED: "not-granted";
+        };
+        readonly default: "granted";
+    };
+    readonly beforeSend: {
+        readonly type: "function";
+        readonly signature: ((event: any, context?: any) => unknown) | undefined;
+    };
+    readonly source: {
+        readonly type: "enum";
+        readonly values: readonly ["browser", "flutter", "unity"];
+        readonly default: "browser";
+        readonly strict: false;
+    };
+    readonly sessionPersistence: {
+        readonly type: "enum";
+        readonly values: readonly ["cookie", "local-storage", "memory"];
+        readonly multiple: true;
+        readonly strict: false;
+    };
+    readonly replica: {
+        readonly type: "schema";
+        readonly schema: {
+            readonly clientToken: {
+                readonly type: "string";
+                readonly required: true;
+            };
+            readonly applicationId: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly datacenter: {
+        readonly type: "string";
+    };
+    readonly sdkVersion: {
+        readonly type: "string";
+    };
+    readonly variant: {
+        readonly type: "string";
+    };
+};
+export type LogsConfiguration = InferredConfig<typeof LOGS_SCHEMA>;
+export declare function validateAndBuildLogsConfiguration(initConfiguration: LogsInitConfiguration): LogsConfiguration | undefined;
+export declare function serializeLogsConfiguration(configuration: LogsInitConfiguration): {
+    session_sample_rate: number | undefined;
+    telemetry_sample_rate: number | undefined;
+    telemetry_configuration_sample_rate: number | undefined;
+    telemetry_usage_sample_rate: number | undefined;
+    use_before_send: boolean;
+    use_partitioned_cross_site_session_cookie: boolean | undefined;
+    use_secure_session_cookie: boolean | undefined;
+    use_proxy: boolean;
+    silent_multiple_init: boolean | undefined;
+    track_session_across_subdomains: boolean | undefined;
+    track_anonymous_user: boolean | undefined;
+    session_persistence: import("@kubesense/kubesense-browser-core").SessionPersistence | undefined;
+    store_contexts_across_pages: boolean;
+    allow_untrusted_events: boolean;
+    tracking_consent: import("@kubesense/kubesense-browser-core").TrackingConsent | undefined;
+    use_allowed_tracking_origins: boolean;
+    source: "browser" | "flutter" | "unity" | undefined;
+    sdk_version: string | undefined;
+    variant: string | undefined;
+    forward_errors_to_logs: boolean | undefined;
+    enable_remote_sdk_configuration: boolean;
+    forward_console_logs: ConsoleApiName[] | "all" | undefined;
+    forward_reports: RawReportType[] | "all" | undefined;
+    plugins: {
+        name: string;
+    }[] | undefined;
+};

package/cjs/domain/configuration.js

@@ -0,0 +1,86 @@
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_configuration = require("@kubesense/kubesense-js-core/configuration");
+//#region src/domain/configuration.ts
+const LOGS_SCHEMA = {
+	..._kubesense_kubesense_browser_core.BROWSER_CORE_SCHEMA,
+	forwardErrorsToLogs: {
+		type: "boolean",
+		default: true,
+		strict: false
+	},
+	enableRemoteSdkConfiguration: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	forwardConsoleLogs: {
+		type: "enum",
+		values: _kubesense_kubesense_js_core_util.ConsoleApiName,
+		multiple: true,
+		allowAll: true,
+		default: []
+	},
+	forwardReports: {
+		type: "enum",
+		values: _kubesense_kubesense_browser_core.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 = (0, _kubesense_kubesense_js_core_configuration.validateAndBuildConfiguration)(initConfiguration, LOGS_SCHEMA, _kubesense_kubesense_browser_core.display);
+	if (!config) return;
+	return {
+		...config,
+		beforeSend: config.beforeSend ? (0, _kubesense_kubesense_browser_core.catchUserErrors)(config.beforeSend, "beforeSend threw an error:") : void 0
+	};
+}
+function serializeLogsConfiguration(configuration) {
+	const baseSerializedInitConfiguration = (0, _kubesense_kubesense_browser_core.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
+exports.LOGS_SCHEMA = LOGS_SCHEMA;
+exports.serializeLogsConfiguration = serializeLogsConfiguration;
+exports.validateAndBuildLogsConfiguration = validateAndBuildLogsConfiguration;
+
+//# sourceMappingURL=configuration.js.map

package/cjs/domain/configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.js","names":["BROWSER_CORE_SCHEMA","ConsoleApiName","RawReportType","validateAndBuildConfiguration","display","catchUserErrors","serializeConfiguration"],"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,GAAGA,kCAAAA;CACH,qBAAqB;EAAE,MAAM;EAAW,SAAS;EAAM,QAAQ;CAAM;CACrE,8BAA8B;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CAC/E,oBAAoB;EAClB,MAAM;EACN,QAAQC,kCAAAA;EACR,UAAU;EACV,UAAU;EACV,SAAS,CAAC;CACZ;CACA,gBAAgB;EACd,MAAM;EACN,QAAQC,kCAAAA;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,UAAA,GAASC,2CAAAA,8BAAAA,CACb,mBACA,aACAC,kCAAAA,OACF;CACA,IAAI,CAAC,QACH;CAEF,OAAO;EACL,GAAG;EACH,YAAY,OAAO,cAAA,GAAaC,kCAAAA,gBAAAA,CAAgB,OAAO,YAAmB,4BAA4B,IAAI,KAAA;CAC5G;AACF;AAEA,SAAgB,2BAA2B,eAAsC;CAC/E,MAAM,mCAAA,GAAkCC,kCAAAA,uBAAAA,CAAuB,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/cjs/domain/console/consoleCollection.d.ts

@@ -0,0 +1,20 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time';
+import type { Context, Observable, BufferedData } from '@kubesense/kubesense-browser-core';
+import type { LogsConfiguration } from '../configuration';
+import type { LifeCycle } from '../lifeCycle';
+export interface ProvidedError {
+    startClocks: ClocksState;
+    error: unknown;
+    context?: Context;
+    handlingStack: string;
+}
+export declare const LogStatusForApi: {
+    log: "info";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+    error: "error";
+};
+export declare function startConsoleCollection(configuration: LogsConfiguration, lifeCycle: LifeCycle, bufferedDataObservable: Observable<BufferedData>): {
+    stop: () => void;
+};

package/cjs/domain/console/consoleCollection.js

@@ -0,0 +1,37 @@
+const require_isAuthorized = require("../logger/isAuthorized.js");
+const require_createErrorFieldFromRawError = require("../createErrorFieldFromRawError.js");
+require("../lifeCycle.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/console/consoleCollection.ts
+const LogStatusForApi = {
+	[_kubesense_kubesense_js_core_util.ConsoleApiName.log]: require_isAuthorized.StatusType.info,
+	[_kubesense_kubesense_js_core_util.ConsoleApiName.debug]: require_isAuthorized.StatusType.debug,
+	[_kubesense_kubesense_js_core_util.ConsoleApiName.info]: require_isAuthorized.StatusType.info,
+	[_kubesense_kubesense_js_core_util.ConsoleApiName.warn]: require_isAuthorized.StatusType.warn,
+	[_kubesense_kubesense_js_core_util.ConsoleApiName.error]: require_isAuthorized.StatusType.error
+};
+function startConsoleCollection(configuration, lifeCycle, bufferedDataObservable) {
+	const subscription = bufferedDataObservable.subscribe(({ data: log, type }) => {
+		if (type !== _kubesense_kubesense_browser_core.BufferedDataType.CONSOLE || !configuration.forwardConsoleLogs.includes(log.api)) return;
+		const collectedData = {
+			rawLogsEvent: (0, _kubesense_kubesense_js_core_util.combine)({
+				date: (0, _kubesense_kubesense_js_core_time.timeStampNow)(),
+				message: log.message,
+				origin: _kubesense_kubesense_browser_core.ErrorSource.CONSOLE,
+				error: log.error && require_createErrorFieldFromRawError.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
+exports.LogStatusForApi = LogStatusForApi;
+exports.startConsoleCollection = startConsoleCollection;
+
+//# sourceMappingURL=consoleCollection.js.map

package/cjs/domain/console/consoleCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleCollection.js","names":["ConsoleApiName","StatusType","BufferedDataType","combine","timeStampNow","ErrorSource","createErrorFieldFromRawError"],"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;EAC5BA,kCAAAA,eAAe,MAAMC,qBAAAA,WAAW;EAChCD,kCAAAA,eAAe,QAAQC,qBAAAA,WAAW;EAClCD,kCAAAA,eAAe,OAAOC,qBAAAA,WAAW;EACjCD,kCAAAA,eAAe,OAAOC,qBAAAA,WAAW;EACjCD,kCAAAA,eAAe,QAAQC,qBAAAA,WAAW;AACrC;AAEA,SAAgB,uBACd,eACA,WACA,wBACA;CACA,MAAM,eAAe,uBAAuB,WAAW,EAAE,MAAM,KAAK,WAAW;EAC7E,IAAI,SAASC,kCAAAA,iBAAiB,WAAW,CAAC,cAAc,mBAAmB,SAAS,IAAI,GAAG,GACzF;EAEF,MAAM,gBAAyD;GAC7D,eAAA,GAAcC,kCAAAA,QAAAA,CACZ;IACE,OAAA,GAAMC,kCAAAA,aAAAA,CAAa;IACnB,SAAS,IAAI;IACb,QAAQC,kCAAAA,YAAY;IACpB,OAAO,IAAI,SAASC,qCAAAA,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/cjs/domain/contexts/commonContext.d.ts

@@ -0,0 +1,2 @@
+import type { CommonContext } from '../../rawLogsEvent.types';
+export declare function buildCommonContext(): CommonContext;

package/cjs/domain/contexts/commonContext.js

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

package/cjs/domain/contexts/commonContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonContext.js","names":["isWorkerEnvironment"],"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,IAAIA,kCAAAA,qBACF,OAAO,CAAC;CAGV,OAAO,EACL,MAAM;EACJ,UAAU,SAAS;EACnB,KAAK,OAAO,SAAS;CACvB,EACF;AACF"}

package/cjs/domain/contexts/internalContext.d.ts

@@ -0,0 +1,7 @@
+import type { SessionManager } from '@kubesense/kubesense-browser-core';
+export interface InternalContext {
+    session_id: string | undefined;
+}
+export declare function startInternalContext(sessionManager: SessionManager): {
+    get: (startTime?: number) => InternalContext | undefined;
+};

package/cjs/domain/contexts/internalContext.js

@@ -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
+exports.startInternalContext = startInternalContext;
+
+//# sourceMappingURL=internalContext.js.map

package/cjs/domain/contexts/internalContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalContext.js","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/cjs/domain/contexts/rumInternalContext.d.ts

@@ -0,0 +1,2 @@
+import type { Hooks } from '../hooks';
+export declare function startRUMInternalContext(hooks: Hooks): void;

package/cjs/domain/contexts/rumInternalContext.js

@@ -0,0 +1,32 @@
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_assembly = require("@kubesense/kubesense-js-core/assembly");
+//#region src/domain/contexts/rumInternalContext.ts
+function startRUMInternalContext(hooks) {
+	const browserWindow = _kubesense_kubesense_js_core_util.globalObject;
+	hooks.assembleEventDefaults.register(({ startTime }) => {
+		const internalContext = getRUMInternalContext(startTime);
+		if (!internalContext) return _kubesense_kubesense_js_core_assembly.SKIPPED;
+		return internalContext;
+	});
+	hooks.assembleTelemetry.register(({ startTime }) => {
+		const internalContext = getRUMInternalContext(startTime);
+		if (!internalContext) return _kubesense_kubesense_js_core_assembly.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, (0, _kubesense_kubesense_browser_core.willSyntheticsInjectRum)() ? browserWindow.KUBESENSE_SDK_SYNTHETICS : browserWindow.KUBESENSE_SDK);
+		if (rumContext) return rumContext;
+	}
+	function getInternalContextFromRumGlobal(startTime, rumGlobal) {
+		if (rumGlobal?.getInternalContext) return rumGlobal.getInternalContext(startTime);
+	}
+}
+//#endregion
+exports.startRUMInternalContext = startRUMInternalContext;
+
+//# sourceMappingURL=rumInternalContext.js.map

package/cjs/domain/contexts/rumInternalContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rumInternalContext.js","names":["globalObject","SKIPPED","willSyntheticsInjectRum"],"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,gBAAgBA,kCAAAA;CAEtB,MAAM,sBAAsB,UAAU,EAAE,gBAAgB;EACtD,MAAM,kBAAkB,sBAAsB,SAAS;EACvD,IAAI,CAAC,iBACH,OAAOC,sCAAAA;EAGT,OAAO;CACT,CAAC;CAED,MAAM,kBAAkB,UAAU,EAAE,gBAAgB;EAClD,MAAM,kBAAkB,sBAAsB,SAAS;EAEvD,IAAI,CAAC,iBACH,OAAOA,sCAAAA;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,YAAA,GAJbC,kCAAAA,wBAAAA,CACQ,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/cjs/domain/contexts/sessionContext.d.ts

@@ -0,0 +1,4 @@
+import type { SessionManager } from '@kubesense/kubesense-browser-core';
+import type { LogsConfiguration } from '../configuration';
+import type { AssembleHook } from '../hooks';
+export declare function startSessionContext(hook: AssembleHook, configuration: LogsConfiguration, sessionManager: SessionManager): void;

package/cjs/domain/contexts/sessionContext.js

@@ -0,0 +1,20 @@
+let _kubesense_kubesense_js_core_assembly = require("@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 _kubesense_kubesense_js_core_assembly.DISCARDED;
+		return {
+			service: configuration.service,
+			session_id: session ? session.id : void 0,
+			session: session ? { id: session.id } : void 0
+		};
+	});
+}
+//#endregion
+exports.startSessionContext = startSessionContext;
+
+//# sourceMappingURL=sessionContext.js.map

package/cjs/domain/contexts/sessionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionContext.js","names":["DISCARDED"],"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,OAAOA,sCAAAA;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/cjs/domain/contexts/trackingConsentContext.d.ts

@@ -0,0 +1,3 @@
+import type { TrackingConsentState } from '@kubesense/kubesense-browser-core';
+import type { Hooks } from '../hooks';
+export declare function startTrackingConsentContext(hooks: Hooks, trackingConsentState: TrackingConsentState): void;

package/cjs/domain/contexts/trackingConsentContext.js

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

package/cjs/domain/contexts/trackingConsentContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackingConsentContext.js","names":["DISCARDED","SKIPPED"],"sources":["../../../src/domain/contexts/trackingConsentContext.ts"],"sourcesContent":["import { DISCARDED, SKIPPED } from '@kubesense/kubesense-js-core/assembly'\nimport type { TrackingConsentState } from '@kubesense/kubesense-browser-core'\nimport type { Hooks } from '../hooks'\n\nexport function startTrackingConsentContext(hooks: Hooks, trackingConsentState: TrackingConsentState) {\n  function isConsented() {\n    const wasConsented = trackingConsentState.isGranted()\n\n    if (!wasConsented) {\n      return DISCARDED\n    }\n\n    return SKIPPED\n  }\n\n  hooks.assembleEventDefaults.register(isConsented)\n  hooks.assembleTelemetry.register(isConsented)\n}\n"],"mappings":";;AAIA,SAAgB,4BAA4B,OAAc,sBAA4C;CACpG,SAAS,cAAc;EAGrB,IAAI,CAFiB,qBAAqB,UAE1B,GACd,OAAOA,sCAAAA;EAGT,OAAOC,sCAAAA;CACT;CAEA,MAAM,sBAAsB,SAAS,WAAW;CAChD,MAAM,kBAAkB,SAAS,WAAW;AAC9C"}

package/cjs/domain/createErrorFieldFromRawError.d.ts

@@ -0,0 +1,10 @@
+import type { RawError } from '@kubesense/kubesense-browser-core';
+import type { RawLoggerLogsEvent } from '../rawLogsEvent.types';
+export declare function createErrorFieldFromRawError(rawError: RawError, { 
+/**
+ * Set this to `true` to include the error message in the error field. In most cases, the error
+ * message is already included in the log message, so we don't need to include it again.
+ */
+includeMessage, }?: {
+    includeMessage?: boolean | undefined;
+}): NonNullable<RawLoggerLogsEvent['error']>;