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

package/cjs/domain/remoteSdkConfiguration.js

@@ -0,0 +1,67 @@
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/remoteSdkConfiguration.ts
+function applyCachedLogsSdkConfiguration(initConfiguration) {
+	const remoteConfig = (0, _kubesense_kubesense_browser_core.getCachedSdkConfig)(initConfiguration.clientToken);
+	if (!remoteConfig) return {
+		initConfiguration,
+		logsEnabled: true
+	};
+	return applyLogsSdkConfiguration(initConfiguration, remoteConfig);
+}
+function applyLogsSdkConfiguration(initConfiguration, remoteConfig) {
+	const features = remoteConfig.features;
+	if ((0, _kubesense_kubesense_browser_core.readBoolean)(features, "logs") === false) return {
+		initConfiguration,
+		logsEnabled: false
+	};
+	const logs = remoteConfig.logs;
+	if (!logs) return {
+		initConfiguration,
+		logsEnabled: true
+	};
+	const applied = { ...initConfiguration };
+	assign(applied, "sessionSampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(logs, "sessionSampleRate"));
+	assign(applied, "telemetrySampleRate", (0, _kubesense_kubesense_browser_core.readSampleRate)(logs, "telemetrySampleRate"));
+	assign(applied, "forwardErrorsToLogs", (0, _kubesense_kubesense_browser_core.readBoolean)(logs, "forwardErrorsToLogs"));
+	assign(applied, "trackAnonymousUser", (0, _kubesense_kubesense_browser_core.readBoolean)(logs, "trackAnonymousUser"));
+	assign(applied, "trackSessionAcrossSubdomains", (0, _kubesense_kubesense_browser_core.readBoolean)(logs, "trackSessionAcrossSubdomains"));
+	assign(applied, "allowedTrackingOrigins", (0, _kubesense_kubesense_browser_core.readStringList)(logs.allowedTrackingOrigins));
+	assign(applied, "forwardConsoleLogs", readForwardList(logs.forwardConsoleLogs, (0, _kubesense_kubesense_browser_core.objectValues)(_kubesense_kubesense_js_core_util.ConsoleApiName)));
+	assign(applied, "forwardReports", readForwardList(logs.forwardReports, (0, _kubesense_kubesense_browser_core.objectValues)(_kubesense_kubesense_browser_core.RawReportType)));
+	assign(applied, "service", (0, _kubesense_kubesense_browser_core.readString)(logs, "service"));
+	assign(applied, "env", (0, _kubesense_kubesense_browser_core.readString)(logs, "env"));
+	assign(applied, "version", (0, _kubesense_kubesense_browser_core.readString)(logs, "version"));
+	return {
+		initConfiguration: applied,
+		logsEnabled: true
+	};
+}
+/**
+* `forwardConsoleLogs` and `forwardReports` accept either the literal `'all'` or a subset of the
+* known names. Unknown names are dropped rather than passed through, so a document written against
+* a newer SDK cannot turn the option into a value this SDK will reject wholesale.
+*/
+function readForwardList(value, allowedValues) {
+	if (value === "all") return "all";
+	const names = (0, _kubesense_kubesense_browser_core.readStringList)(value)?.filter((name) => allowedValues.includes(name));
+	return names?.length ? names : void 0;
+}
+function assign(target, key, value) {
+	if (value !== void 0) target[key] = value;
+}
+/**
+* Refresh the shared cache for the next page load.
+*
+* When RUM and Logs both run on a page they each schedule a refresh; the requests are
+* idempotent GETs and the last response simply wins, so no coordination is needed.
+*/
+function scheduleLogsSdkConfigurationRefresh(initConfiguration) {
+	return (0, _kubesense_kubesense_browser_core.refreshSdkConfig)(initConfiguration);
+}
+//#endregion
+exports.applyCachedLogsSdkConfiguration = applyCachedLogsSdkConfiguration;
+exports.applyLogsSdkConfiguration = applyLogsSdkConfiguration;
+exports.scheduleLogsSdkConfigurationRefresh = scheduleLogsSdkConfigurationRefresh;
+
+//# sourceMappingURL=remoteSdkConfiguration.js.map

package/cjs/domain/remoteSdkConfiguration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteSdkConfiguration.js","names":["getCachedSdkConfig","readBoolean","readSampleRate","readStringList","objectValues","ConsoleApiName","RawReportType","readString","refreshSdkConfig"],"sources":["../../src/domain/remoteSdkConfiguration.ts"],"sourcesContent":["import type { RemoteSdkConfig } from '@kubesense/kubesense-browser-core'\nimport {\n  RawReportType,\n  getCachedSdkConfig,\n  objectValues,\n  readBoolean,\n  readSampleRate,\n  readString,\n  readStringList,\n  refreshSdkConfig,\n} from '@kubesense/kubesense-browser-core'\nimport { ConsoleApiName } from '@kubesense/kubesense-js-core/util'\nimport type { LogsInitConfiguration } from './configuration'\n\n/**\n * Applies the dashboard-managed configuration document to the Logs init configuration.\n *\n * The Logs SDK reads the same cached document as RUM (they share one local-storage entry), but\n * only consumes the `features.logs` switch and the `logs` section — RUM settings never leak\n * into Logs, and vice versa.\n *\n * As in RUM, a missing or invalid field leaves the local `init()` value untouched, and\n * identity/endpoint settings are never remotable.\n */\n\nexport interface LogsRemoteSdkConfigurationResult {\n  initConfiguration: LogsInitConfiguration\n  /** `false` when the dashboard has switched Logs off entirely. */\n  logsEnabled: boolean\n}\n\nexport function applyCachedLogsSdkConfiguration(\n  initConfiguration: LogsInitConfiguration\n): LogsRemoteSdkConfigurationResult {\n  const remoteConfig = getCachedSdkConfig(initConfiguration.clientToken)\n  if (!remoteConfig) {\n    return { initConfiguration, logsEnabled: true }\n  }\n  return applyLogsSdkConfiguration(initConfiguration, remoteConfig)\n}\n\nexport function applyLogsSdkConfiguration(\n  initConfiguration: LogsInitConfiguration,\n  remoteConfig: RemoteSdkConfig\n): LogsRemoteSdkConfigurationResult {\n  const features = remoteConfig.features as { [key: string]: unknown } | undefined\n  if (readBoolean(features, 'logs') === false) {\n    return { initConfiguration, logsEnabled: false }\n  }\n\n  const logs = remoteConfig.logs\n  if (!logs) {\n    return { initConfiguration, logsEnabled: true }\n  }\n\n  const applied: LogsInitConfiguration = { ...initConfiguration }\n\n  assign(applied, 'sessionSampleRate', readSampleRate(logs, 'sessionSampleRate'))\n  assign(applied, 'telemetrySampleRate', readSampleRate(logs, 'telemetrySampleRate'))\n  assign(applied, 'forwardErrorsToLogs', readBoolean(logs, 'forwardErrorsToLogs'))\n  assign(applied, 'trackAnonymousUser', readBoolean(logs, 'trackAnonymousUser'))\n  assign(applied, 'trackSessionAcrossSubdomains', readBoolean(logs, 'trackSessionAcrossSubdomains'))\n  assign(applied, 'allowedTrackingOrigins', readStringList(logs.allowedTrackingOrigins))\n  assign(applied, 'forwardConsoleLogs', readForwardList(logs.forwardConsoleLogs, objectValues(ConsoleApiName)))\n  assign(applied, 'forwardReports', readForwardList(logs.forwardReports, objectValues(RawReportType)))\n\n  assign(applied, 'service', readString(logs, 'service'))\n  assign(applied, 'env', readString(logs, 'env'))\n  assign(applied, 'version', readString(logs, 'version'))\n\n  return { initConfiguration: applied, logsEnabled: true }\n}\n\n/**\n * `forwardConsoleLogs` and `forwardReports` accept either the literal `'all'` or a subset of the\n * known names. Unknown names are dropped rather than passed through, so a document written against\n * a newer SDK cannot turn the option into a value this SDK will reject wholesale.\n */\nfunction readForwardList<T extends string>(value: unknown, allowedValues: readonly T[]): T[] | 'all' | undefined {\n  if (value === 'all') {\n    return 'all'\n  }\n  const names = readStringList(value)?.filter((name): name is T => (allowedValues as readonly string[]).includes(name))\n  return names?.length ? names : undefined\n}\n\nfunction assign<K extends keyof LogsInitConfiguration>(\n  target: LogsInitConfiguration,\n  key: K,\n  value: LogsInitConfiguration[K] | undefined\n) {\n  if (value !== undefined) {\n    target[key] = value\n  }\n}\n\n/**\n * Refresh the shared cache for the next page load.\n *\n * When RUM and Logs both run on a page they each schedule a refresh; the requests are\n * idempotent GETs and the last response simply wins, so no coordination is needed.\n */\nexport function scheduleLogsSdkConfigurationRefresh(initConfiguration: LogsInitConfiguration) {\n  return refreshSdkConfig(initConfiguration)\n}\n"],"mappings":";;;AA+BA,SAAgB,gCACd,mBACkC;CAClC,MAAM,gBAAA,GAAeA,kCAAAA,mBAAAA,CAAmB,kBAAkB,WAAW;CACrE,IAAI,CAAC,cACH,OAAO;EAAE;EAAmB,aAAa;CAAK;CAEhD,OAAO,0BAA0B,mBAAmB,YAAY;AAClE;AAEA,SAAgB,0BACd,mBACA,cACkC;CAClC,MAAM,WAAW,aAAa;CAC9B,KAAA,GAAIC,kCAAAA,YAAAA,CAAY,UAAU,MAAM,MAAM,OACpC,OAAO;EAAE;EAAmB,aAAa;CAAM;CAGjD,MAAM,OAAO,aAAa;CAC1B,IAAI,CAAC,MACH,OAAO;EAAE;EAAmB,aAAa;CAAK;CAGhD,MAAM,UAAiC,EAAE,GAAG,kBAAkB;CAE9D,OAAO,SAAS,sBAAA,GAAqBC,kCAAAA,eAAAA,CAAe,MAAM,mBAAmB,CAAC;CAC9E,OAAO,SAAS,wBAAA,GAAuBA,kCAAAA,eAAAA,CAAe,MAAM,qBAAqB,CAAC;CAClF,OAAO,SAAS,wBAAA,GAAuBD,kCAAAA,YAAAA,CAAY,MAAM,qBAAqB,CAAC;CAC/E,OAAO,SAAS,uBAAA,GAAsBA,kCAAAA,YAAAA,CAAY,MAAM,oBAAoB,CAAC;CAC7E,OAAO,SAAS,iCAAA,GAAgCA,kCAAAA,YAAAA,CAAY,MAAM,8BAA8B,CAAC;CACjG,OAAO,SAAS,2BAAA,GAA0BE,kCAAAA,eAAAA,CAAe,KAAK,sBAAsB,CAAC;CACrF,OAAO,SAAS,sBAAsB,gBAAgB,KAAK,qBAAA,GAAoBC,kCAAAA,aAAAA,CAAaC,kCAAAA,cAAc,CAAC,CAAC;CAC5G,OAAO,SAAS,kBAAkB,gBAAgB,KAAK,iBAAA,GAAgBD,kCAAAA,aAAAA,CAAaE,kCAAAA,aAAa,CAAC,CAAC;CAEnG,OAAO,SAAS,YAAA,GAAWC,kCAAAA,WAAAA,CAAW,MAAM,SAAS,CAAC;CACtD,OAAO,SAAS,QAAA,GAAOA,kCAAAA,WAAAA,CAAW,MAAM,KAAK,CAAC;CAC9C,OAAO,SAAS,YAAA,GAAWA,kCAAAA,WAAAA,CAAW,MAAM,SAAS,CAAC;CAEtD,OAAO;EAAE,mBAAmB;EAAS,aAAa;CAAK;AACzD;;;;;;AAOA,SAAS,gBAAkC,OAAgB,eAAsD;CAC/G,IAAI,UAAU,OACZ,OAAO;CAET,MAAM,SAAA,GAAQJ,kCAAAA,eAAAA,CAAe,KAAK,CAAC,EAAE,QAAQ,SAAqB,cAAoC,SAAS,IAAI,CAAC;CACpH,OAAO,OAAO,SAAS,QAAQ,KAAA;AACjC;AAEA,SAAS,OACP,QACA,KACA,OACA;CACA,IAAI,UAAU,KAAA,GACZ,OAAO,OAAO;AAElB;;;;;;;AAQA,SAAgB,oCAAoC,mBAA0C;CAC5F,QAAA,GAAOK,kCAAAA,iBAAAA,CAAiB,iBAAiB;AAC3C"}

package/cjs/domain/report/reportCollection.d.ts

@@ -0,0 +1,13 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time';
+import type { Context } 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 function startReportCollection(configuration: LogsConfiguration, lifeCycle: LifeCycle): {
+    stop: () => void;
+};

package/cjs/domain/report/reportCollection.js

@@ -0,0 +1,30 @@
+const require_isAuthorized = require("../logger/isAuthorized.js");
+const require_createErrorFieldFromRawError = require("../createErrorFieldFromRawError.js");
+require("../lifeCycle.js");
+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/report/reportCollection.ts
+function startReportCollection(configuration, lifeCycle) {
+	const reportSubscription = (0, _kubesense_kubesense_browser_core.initReportObservable)(configuration.forwardReports).subscribe((rawError) => {
+		let message = rawError.message;
+		let error;
+		const status = rawError.originalError.type === "deprecation" ? require_isAuthorized.StatusType.warn : require_isAuthorized.StatusType.error;
+		if (status === require_isAuthorized.StatusType.error) error = require_createErrorFieldFromRawError.createErrorFieldFromRawError(rawError);
+		else if (rawError.stack) message += ` Found in ${(0, _kubesense_kubesense_browser_core.getFileFromStackTraceString)(rawError.stack)}`;
+		lifeCycle.notify(0, { rawLogsEvent: {
+			date: (0, _kubesense_kubesense_js_core_time.timeStampNow)(),
+			message,
+			origin: _kubesense_kubesense_browser_core.ErrorSource.REPORT,
+			error,
+			_kubesense: { debug_ids: rawError.debugIds },
+			status
+		} });
+	});
+	return { stop: () => {
+		reportSubscription.unsubscribe();
+	} };
+}
+//#endregion
+exports.startReportCollection = startReportCollection;
+
+//# sourceMappingURL=reportCollection.js.map

package/cjs/domain/report/reportCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportCollection.js","names":["initReportObservable","StatusType","createErrorFieldFromRawError","getFileFromStackTraceString","timeStampNow","ErrorSource"],"sources":["../../../src/domain/report/reportCollection.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport type { Context } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport { ErrorSource, getFileFromStackTraceString, initReportObservable } from '@kubesense/kubesense-browser-core'\nimport type { LogsConfiguration } from '../configuration'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { StatusType } from '../logger/isAuthorized'\nimport { createErrorFieldFromRawError } from '../createErrorFieldFromRawError'\n\nexport interface ProvidedError {\n  startClocks: ClocksState\n  error: unknown\n  context?: Context\n  handlingStack: string\n}\n\nexport function startReportCollection(configuration: LogsConfiguration, lifeCycle: LifeCycle) {\n  const reportSubscription = initReportObservable(configuration.forwardReports).subscribe((rawError) => {\n    let message = rawError.message\n    let error\n    const status = rawError.originalError.type === 'deprecation' ? StatusType.warn : StatusType.error\n\n    if (status === StatusType.error) {\n      error = createErrorFieldFromRawError(rawError)\n    } else if (rawError.stack) {\n      message += ` Found in ${getFileFromStackTraceString(rawError.stack)!}`\n    }\n\n    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {\n      rawLogsEvent: {\n        date: timeStampNow(),\n        message,\n        origin: ErrorSource.REPORT,\n        error,\n        _kubesense: { debug_ids: rawError.debugIds },\n        status,\n      },\n    })\n  })\n\n  return {\n    stop: () => {\n      reportSubscription.unsubscribe()\n    },\n  }\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,sBAAsB,eAAkC,WAAsB;CAC5F,MAAM,sBAAA,GAAqBA,kCAAAA,qBAAAA,CAAqB,cAAc,cAAc,CAAC,CAAC,WAAW,aAAa;EACpG,IAAI,UAAU,SAAS;EACvB,IAAI;EACJ,MAAM,SAAS,SAAS,cAAc,SAAS,gBAAgBC,qBAAAA,WAAW,OAAOA,qBAAAA,WAAW;EAE5F,IAAI,WAAWA,qBAAAA,WAAW,OACxB,QAAQC,qCAAAA,6BAA6B,QAAQ;OACxC,IAAI,SAAS,OAClB,WAAW,cAAA,GAAaC,kCAAAA,4BAAAA,CAA4B,SAAS,KAAK;EAGpE,UAAU,OAAA,GAA6C,EACrD,cAAc;GACZ,OAAA,GAAMC,kCAAAA,aAAAA,CAAa;GACnB;GACA,QAAQC,kCAAAA,YAAY;GACpB;GACA,YAAY,EAAE,WAAW,SAAS,SAAS;GAC3C;EACF,EACF,CAAC;CACH,CAAC;CAED,OAAO,EACL,YAAY;EACV,mBAAmB,YAAY;CACjC,EACF;AACF"}

package/cjs/domain/reportError.d.ts

@@ -0,0 +1,2 @@
+import type { LifeCycle } from './lifeCycle';
+export declare function startReportError(lifeCycle: LifeCycle): (message: string) => void;

package/cjs/domain/reportError.js

@@ -0,0 +1,20 @@
+const require_isAuthorized = require("./logger/isAuthorized.js");
+require("./lifeCycle.js");
+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/reportError.ts
+function startReportError(lifeCycle) {
+	return (message) => {
+		lifeCycle.notify(0, { rawLogsEvent: {
+			message,
+			date: (0, _kubesense_kubesense_js_core_time.timeStampNow)(),
+			origin: _kubesense_kubesense_browser_core.ErrorSource.AGENT,
+			status: require_isAuthorized.StatusType.error
+		} });
+		(0, _kubesense_kubesense_browser_core.addTelemetryDebug)("Error reported to customer", { "error.message": message });
+	};
+}
+//#endregion
+exports.startReportError = startReportError;
+
+//# sourceMappingURL=reportError.js.map

package/cjs/domain/reportError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportError.js","names":["timeStampNow","ErrorSource","StatusType"],"sources":["../../src/domain/reportError.ts"],"sourcesContent":["import { ErrorSource, addTelemetryDebug } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { LifeCycle } from './lifeCycle'\nimport { LifeCycleEventType } from './lifeCycle'\nimport { StatusType } from './logger/isAuthorized'\n\nexport function startReportError(lifeCycle: LifeCycle) {\n  return (message: string) => {\n    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {\n      rawLogsEvent: {\n        message,\n        date: timeStampNow(),\n        origin: ErrorSource.AGENT,\n        status: StatusType.error,\n      },\n    })\n    // monitor-until: forever, to keep an eye on the errors reported to customers\n    addTelemetryDebug('Error reported to customer', { 'error.message': message })\n  }\n}\n"],"mappings":";;;;;AAMA,SAAgB,iBAAiB,WAAsB;CACrD,QAAQ,YAAoB;EAC1B,UAAU,OAAA,GAA6C,EACrD,cAAc;GACZ;GACA,OAAA,GAAMA,kCAAAA,aAAAA,CAAa;GACnB,QAAQC,kCAAAA,YAAY;GACpB,QAAQC,qBAAAA,WAAW;EACrB,EACF,CAAC;EAED,CAAA,GAAA,kCAAA,kBAAA,CAAkB,8BAA8B,EAAE,iBAAiB,QAAQ,CAAC;CAC9E;AACF"}

package/cjs/domain/runtimeError/runtimeErrorCollection.d.ts

@@ -0,0 +1,14 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time';
+import type { Context, Observable, BufferedData } from '@kubesense/kubesense-browser-core';
+import { noop } 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 function startRuntimeErrorCollection(configuration: LogsConfiguration, lifeCycle: LifeCycle, bufferedDataObservable: Observable<BufferedData>): {
+    stop: typeof noop;
+};

package/cjs/domain/runtimeError/runtimeErrorCollection.js

@@ -0,0 +1,29 @@
+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");
+//#region src/domain/runtimeError/runtimeErrorCollection.ts
+function startRuntimeErrorCollection(configuration, lifeCycle, bufferedDataObservable) {
+	if (!configuration.forwardErrorsToLogs) return { stop: _kubesense_kubesense_browser_core.noop };
+	const rawErrorSubscription = bufferedDataObservable.subscribe((bufferedData) => {
+		if (bufferedData.type === _kubesense_kubesense_browser_core.BufferedDataType.RUNTIME_ERROR) {
+			const error = bufferedData.data;
+			lifeCycle.notify(0, { rawLogsEvent: (0, _kubesense_kubesense_js_core_util.combine)({
+				message: error.message,
+				date: error.startClocks.timeStamp,
+				error: require_createErrorFieldFromRawError.createErrorFieldFromRawError(error),
+				_kubesense: { debug_ids: error.debugIds },
+				origin: _kubesense_kubesense_browser_core.ErrorSource.SOURCE,
+				status: require_isAuthorized.StatusType.error
+			}, error.context) });
+		}
+	});
+	return { stop: () => {
+		rawErrorSubscription.unsubscribe();
+	} };
+}
+//#endregion
+exports.startRuntimeErrorCollection = startRuntimeErrorCollection;
+
+//# sourceMappingURL=runtimeErrorCollection.js.map

package/cjs/domain/runtimeError/runtimeErrorCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeErrorCollection.js","names":["noop","BufferedDataType","combine","createErrorFieldFromRawError","ErrorSource","StatusType"],"sources":["../../../src/domain/runtimeError/runtimeErrorCollection.ts"],"sourcesContent":["import type { ClocksState } from '@kubesense/kubesense-js-core/time'\nimport { combine } from '@kubesense/kubesense-js-core/util'\nimport type { Context, Observable, BufferedData } from '@kubesense/kubesense-browser-core'\nimport { noop, ErrorSource, BufferedDataType } from '@kubesense/kubesense-browser-core'\nimport type { LogsConfiguration } from '../configuration'\nimport type { LifeCycle } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { StatusType } from '../logger/isAuthorized'\nimport { createErrorFieldFromRawError } from '../createErrorFieldFromRawError'\n\nexport interface ProvidedError {\n  startClocks: ClocksState\n  error: unknown\n  context?: Context\n  handlingStack: string\n}\n\nexport function startRuntimeErrorCollection(\n  configuration: LogsConfiguration,\n  lifeCycle: LifeCycle,\n  bufferedDataObservable: Observable<BufferedData>\n) {\n  if (!configuration.forwardErrorsToLogs) {\n    return { stop: noop }\n  }\n\n  const rawErrorSubscription = bufferedDataObservable.subscribe((bufferedData) => {\n    if (bufferedData.type === BufferedDataType.RUNTIME_ERROR) {\n      const error = bufferedData.data\n      lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {\n        rawLogsEvent: combine(\n          {\n            message: error.message,\n            date: error.startClocks.timeStamp,\n            error: createErrorFieldFromRawError(error),\n            _kubesense: { debug_ids: error.debugIds },\n            origin: ErrorSource.SOURCE,\n            status: StatusType.error,\n          },\n          error.context\n        ),\n      })\n    }\n  })\n\n  return {\n    stop: () => {\n      rawErrorSubscription.unsubscribe()\n    },\n  }\n}\n"],"mappings":";;;;;;AAiBA,SAAgB,4BACd,eACA,WACA,wBACA;CACA,IAAI,CAAC,cAAc,qBACjB,OAAO,EAAE,MAAMA,kCAAAA,KAAK;CAGtB,MAAM,uBAAuB,uBAAuB,WAAW,iBAAiB;EAC9E,IAAI,aAAa,SAASC,kCAAAA,iBAAiB,eAAe;GACxD,MAAM,QAAQ,aAAa;GAC3B,UAAU,OAAA,GAA6C,EACrD,eAAA,GAAcC,kCAAAA,QAAAA,CACZ;IACE,SAAS,MAAM;IACf,MAAM,MAAM,YAAY;IACxB,OAAOC,qCAAAA,6BAA6B,KAAK;IACzC,YAAY,EAAE,WAAW,MAAM,SAAS;IACxC,QAAQC,kCAAAA,YAAY;IACpB,QAAQC,qBAAAA,WAAW;GACrB,GACA,MAAM,OACR,EACF,CAAC;EACH;CACF,CAAC;CAED,OAAO,EACL,YAAY;EACV,qBAAqB,YAAY;CACnC,EACF;AACF"}

package/cjs/domainContext.types.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorSource } from '@kubesense/kubesense-browser-core';
+export type LogsEventDomainContext<T extends ErrorSource = any> = T extends typeof ErrorSource.NETWORK ? NetworkLogsEventDomainContext : T extends typeof ErrorSource.CONSOLE ? ConsoleLogsEventDomainContext : T extends typeof ErrorSource.LOGGER ? LoggerLogsEventDomainContext : undefined;
+export interface NetworkLogsEventDomainContext {
+    handlingStack?: string;
+}
+export interface ConsoleLogsEventDomainContext {
+    handlingStack: string;
+}
+export interface LoggerLogsEventDomainContext {
+    handlingStack: string;
+}

package/cjs/entries/main.d.ts

@@ -0,0 +1,33 @@
+/**
+ *
+ * KubeSense Browser Logs SDK for collecting and forwarding browser logs to KubeSense.
+ * Provides comprehensive logging capabilities with automatic error tracking and custom log collection.
+ *
+ * @packageDocumentation
+ * @see [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript/)
+ */
+import type { LogsPublicApi } from '../boot/logsPublicApi';
+export type { InternalContext } from '../domain/contexts/internalContext';
+export type { LogsMessage } from '../domain/logger';
+export { Logger, HandlerType } from '../domain/logger';
+export { StatusType } from '../domain/logger/isAuthorized';
+export type { LoggerConfiguration, LogsPublicApi as KubesenseLogs } from '../boot/logsPublicApi';
+export type { LogsInitConfiguration, LogsBeforeSend } from '../domain/configuration';
+export type { LogsEvent } from '../logsEvent.types';
+export type { LogsPlugin, OnLogsStartOptions, OnInitOptions } from '../domain/plugins';
+export type { LogsEventDomainContext, NetworkLogsEventDomainContext, ConsoleLogsEventDomainContext, LoggerLogsEventDomainContext, } from '../domainContext.types';
+/**
+ * @deprecated Use {@link KubesenseLogs} instead
+ */
+export type LogsGlobal = LogsPublicApi;
+export type { InitConfiguration, PublicApi, Context, ContextValue, ContextArray, User, Account, TraceContextInjection, SessionPersistence, TrackingConsent, MatchOption, RawReportType, ErrorSource, } from '@kubesense/kubesense-browser-core';
+export type { ProxyFn, Site } from '@kubesense/kubesense-js-core/transport';
+export type { ConsoleApiName } from '@kubesense/kubesense-js-core/util';
+/**
+ * The global Logs instance. Use this to call Logs methods.
+ *
+ * @category Main
+ * @see {@link KubesenseLogs}
+ * @see [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript/)
+ */
+export declare const kubesenseLogs: LogsPublicApi;

package/cjs/entries/main.js

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_isAuthorized = require("../domain/logger/isAuthorized.js");
+const require_logger = require("../domain/logger.js");
+const require_logsPublicApi = require("../boot/logsPublicApi.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/entries/main.ts
+/**
+*
+* KubeSense Browser Logs SDK for collecting and forwarding browser logs to KubeSense.
+* Provides comprehensive logging capabilities with automatic error tracking and custom log collection.
+*
+* @packageDocumentation
+* @see [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript/)
+*/
+/**
+* The global Logs instance. Use this to call Logs methods.
+*
+* @category Main
+* @see {@link KubesenseLogs}
+* @see [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript/)
+*/
+const kubesenseLogs = require_logsPublicApi.makeLogsPublicApi({ sdkName: "logs" });
+(0, _kubesense_kubesense_browser_core.defineGlobal)(_kubesense_kubesense_js_core_util.globalObject, "KUBESENSE_LOGS", kubesenseLogs);
+//#endregion
+exports.HandlerType = require_logger.HandlerType;
+exports.Logger = require_logger.Logger;
+exports.StatusType = require_isAuthorized.StatusType;
+exports.kubesenseLogs = kubesenseLogs;
+
+//# sourceMappingURL=main.js.map

package/cjs/entries/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","names":["makeLogsPublicApi","defineGlobal","globalObject"],"sources":["../../src/entries/main.ts"],"sourcesContent":["/**\n *\n * KubeSense Browser Logs SDK for collecting and forwarding browser logs to KubeSense.\n * Provides comprehensive logging capabilities with automatic error tracking and custom log collection.\n *\n * @packageDocumentation\n * @see [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript/)\n */\n\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { defineGlobal } from '@kubesense/kubesense-browser-core'\nimport type { LogsPublicApi } from '../boot/logsPublicApi'\nimport { makeLogsPublicApi } from '../boot/logsPublicApi'\n\nexport type { InternalContext } from '../domain/contexts/internalContext'\nexport type { LogsMessage } from '../domain/logger'\nexport { Logger, HandlerType } from '../domain/logger'\nexport { StatusType } from '../domain/logger/isAuthorized'\nexport type { LoggerConfiguration, LogsPublicApi as KubesenseLogs } from '../boot/logsPublicApi'\nexport type { LogsInitConfiguration, LogsBeforeSend } from '../domain/configuration'\nexport type { LogsEvent } from '../logsEvent.types'\nexport type { LogsPlugin, OnLogsStartOptions, OnInitOptions } from '../domain/plugins'\nexport type {\n  LogsEventDomainContext,\n  NetworkLogsEventDomainContext,\n  ConsoleLogsEventDomainContext,\n  LoggerLogsEventDomainContext,\n} from '../domainContext.types'\n\n/**\n * @deprecated Use {@link KubesenseLogs} instead\n */\nexport type LogsGlobal = LogsPublicApi\n\nexport type {\n  InitConfiguration,\n  PublicApi,\n  Context,\n  ContextValue,\n  ContextArray,\n  User,\n  Account,\n  TraceContextInjection,\n  SessionPersistence,\n  TrackingConsent,\n  MatchOption,\n  RawReportType,\n  ErrorSource,\n} from '@kubesense/kubesense-browser-core'\nexport type { ProxyFn, Site } from '@kubesense/kubesense-js-core/transport'\nexport type { ConsoleApiName } from '@kubesense/kubesense-js-core/util'\n\n/**\n * The global Logs instance. Use this to call Logs methods.\n *\n * @category Main\n * @see {@link KubesenseLogs}\n * @see [Browser Log Collection](https://docs.kubesense.ai/logs/log_collection/javascript/)\n */\nexport const kubesenseLogs = makeLogsPublicApi({ sdkName: 'logs' })\n\ninterface BrowserWindow {\n  KUBESENSE_LOGS?: LogsPublicApi\n}\ndefineGlobal(globalObject as BrowserWindow, 'KUBESENSE_LOGS', kubesenseLogs)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,gBAAgBA,sBAAAA,kBAAkB,EAAE,SAAS,OAAO,CAAC;CAKlEC,GAAAA,kCAAAA,aAAAA,CAAaC,kCAAAA,cAA+B,kBAAkB,aAAa"}

package/cjs/logsEvent.types.d.ts

@@ -0,0 +1,192 @@
+export interface LogsEvent {
+    /**
+     * Start of the log in ms from epoch
+     */
+    date: number;
+    /**
+     * The log message
+     */
+    message: string;
+    /**
+     * The log status
+     */
+    status: 'ok' | 'debug' | 'info' | 'notice' | 'warn' | 'error' | 'critical' | 'alert' | 'emerg';
+    /**
+     * Origin of the log
+     */
+    origin: 'network' | 'source' | 'console' | 'logger' | 'agent' | 'report';
+    /**
+     * UUID of the application
+     */
+    application_id?: string;
+    /**
+     * The service name
+     */
+    service?: string;
+    /**
+     * Tags of the log
+     */
+    ktags?: string;
+    /**
+     * UUID of the session (deprecated in favor of session.id)
+     */
+    session_id?: string;
+    /**
+     * Session properties
+     */
+    session?: {
+        /**
+         * UUID of the session
+         */
+        id?: string;
+        [k: string]: unknown;
+    };
+    /**
+     * View properties
+     */
+    view: {
+        /**
+         * URL that linked to the initial view of the page
+         */
+        referrer?: string;
+        /**
+         * URL of the view
+         */
+        url: string;
+        /**
+         * UUID of the view
+         */
+        id?: string;
+        /**
+         * User defined name of the view
+         */
+        name?: string;
+        [k: string]: unknown;
+    };
+    /**
+     * Logger properties
+     */
+    logger?: {
+        /**
+         * Name of the logger
+         */
+        name: string;
+        [k: string]: unknown;
+    };
+    /**
+     * Error properties
+     */
+    error?: {
+        /**
+         * Kind of the error
+         */
+        kind?: string;
+        /**
+         * Stacktrace of the error
+         */
+        stack?: string;
+        /**
+         * Fingerprint of the error
+         */
+        fingerprint?: string;
+        /**
+         * Message of the error
+         */
+        message?: string;
+        /**
+         * Flattened causes of the error
+         */
+        causes?: Array<{
+            message: string;
+            source: string;
+            type?: string;
+            stack?: string;
+        }>;
+        /**
+         * The language or platform impacting the error stack trace format
+         */
+        source_type?: 'browser' | 'browser+wasm';
+        /**
+         * WebAssembly modules available for stack trace symbolication
+         */
+        wasm_modules?: Array<{
+            url: string;
+            build_id: string;
+        }>;
+        [k: string]: unknown;
+    };
+    /**
+     * Resource properties of the error
+     */
+    http?: {
+        /**
+         * HTTP method of the resource
+         */
+        method: 'POST' | 'GET' | 'HEAD' | 'PUT' | 'DELETE' | 'PATCH';
+        /**
+         * HTTP Status code of the resource
+         */
+        status_code: number;
+        /**
+         * URL of the resource
+         */
+        url: string;
+        [k: string]: unknown;
+    };
+    user_action?: {
+        id: string | string[];
+    };
+    usr?: {
+        /**
+         * Identifier of the user
+         */
+        id?: string;
+        /**
+         * Name of the user
+         */
+        name?: string;
+        /**
+         * Email of the user
+         */
+        email?: string;
+        /**
+         * Mobile phone number of the user
+         */
+        mobile?: string;
+        /**
+         * Identifier of the user across sessions
+         */
+        anonymous_id?: string;
+        [k: string]: unknown;
+    };
+    account?: {
+        /**
+         * Identifier of the account
+         */
+        id: string;
+        /**
+         * Name of the account
+         */
+        name?: string;
+        [k: string]: unknown;
+    };
+    /**
+     * Internal properties
+     */
+    _kubesense?: {
+        /**
+         * Mapping of source file URLs to their debug IDs for source map deobfuscation
+         */
+        debug_ids?: Array<{
+            /**
+             * URL of the source file
+             */
+            url: string;
+            /**
+             * Debug ID (UUID) for the source file
+             */
+            id: string;
+        }>;
+    };
+    [k: string]: unknown;
+}

package/cjs/rawLogsEvent.types.d.ts

@@ -0,0 +1,59 @@
+import type { ErrorSource, RawErrorCause, ErrorHandling, DebugIdEntry } from '@kubesense/kubesense-browser-core';
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time';
+import type { StatusType } from './domain/logger/isAuthorized';
+export type RawLogsEvent = RawConsoleLogsEvent | RawNetworkLogsEvent | RawLoggerLogsEvent | RawAgentLogsEvent | RawReportLogsEvent | RawRuntimeLogsEvent;
+interface Error {
+    message?: string;
+    kind?: string;
+    stack?: string;
+    fingerprint?: string;
+    causes?: RawErrorCause[];
+    handling: ErrorHandling | undefined;
+}
+export interface CommonRawLogsEvent {
+    date: TimeStamp;
+    message: string;
+    status: StatusType;
+    error?: Error;
+    origin: ErrorSource;
+    _kubesense?: {
+        debug_ids?: DebugIdEntry[];
+    };
+    [key: string]: unknown;
+}
+export interface RawConsoleLogsEvent extends CommonRawLogsEvent {
+    origin: typeof ErrorSource.CONSOLE;
+}
+export interface RawLoggerLogsEvent extends CommonRawLogsEvent {
+    origin: typeof ErrorSource.LOGGER;
+}
+export interface RawNetworkLogsEvent extends CommonRawLogsEvent {
+    origin: typeof ErrorSource.NETWORK;
+    status: typeof StatusType.error;
+    error: Error;
+    http: {
+        method: 'POST' | 'GET' | 'HEAD' | 'PUT' | 'DELETE' | 'PATCH';
+        status_code: number;
+        url: string;
+        [k: string]: unknown;
+    };
+}
+export interface RawReportLogsEvent extends CommonRawLogsEvent {
+    origin: typeof ErrorSource.REPORT;
+}
+export interface RawRuntimeLogsEvent extends CommonRawLogsEvent {
+    origin: typeof ErrorSource.SOURCE;
+    status: typeof StatusType.error;
+    error: Error;
+}
+export interface RawAgentLogsEvent extends CommonRawLogsEvent {
+    origin: typeof ErrorSource.AGENT;
+    status: typeof StatusType.error;
+}
+export interface CommonContext {
+    view?: {
+        referrer: string;
+        url: string;
+    };
+}
+export {};

package/cjs/transport/startLogsBatch.d.ts

@@ -0,0 +1,4 @@
+import type { SessionManager } from '@kubesense/kubesense-browser-core';
+import type { LogsConfiguration } from '../domain/configuration';
+import type { LifeCycle } from '../domain/lifeCycle';
+export declare function startLogsBatch(configuration: LogsConfiguration, lifeCycle: LifeCycle, reportError: (message: string) => void, sessionManager: SessionManager): import("@kubesense/kubesense-browser-core").Batch;

package/cjs/transport/startLogsBatch.js

@@ -0,0 +1,22 @@
+require("../domain/lifeCycle.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_transport = require("@kubesense/kubesense-js-core/transport");
+//#region src/transport/startLogsBatch.ts
+function startLogsBatch(configuration, lifeCycle, reportError, sessionManager) {
+	const endpoints = [(0, _kubesense_kubesense_js_core_transport.createEndpointBuilder)(configuration, "logs")];
+	const replicaEndpoint = (0, _kubesense_kubesense_js_core_transport.createReplicaEndpointBuilder)(configuration, "logs");
+	if (replicaEndpoint) endpoints.push(replicaEndpoint);
+	const batch = (0, _kubesense_kubesense_browser_core.createBatch)({
+		endpoints,
+		reportError
+	});
+	sessionManager.expireObservable.subscribe(() => batch.forceFlush("session_expire"));
+	lifeCycle.subscribe(1, (serverLogsEvent) => {
+		batch.add(serverLogsEvent);
+	});
+	return batch;
+}
+//#endregion
+exports.startLogsBatch = startLogsBatch;
+
+//# sourceMappingURL=startLogsBatch.js.map

package/cjs/transport/startLogsBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startLogsBatch.js","names":["createEndpointBuilder","createReplicaEndpointBuilder","createBatch"],"sources":["../../src/transport/startLogsBatch.ts"],"sourcesContent":["import type { Context, SessionManager } from '@kubesense/kubesense-browser-core'\nimport { createBatch } from '@kubesense/kubesense-browser-core'\nimport { createEndpointBuilder, createReplicaEndpointBuilder } from '@kubesense/kubesense-js-core/transport'\nimport type { LogsConfiguration } from '../domain/configuration'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { LogsEvent } from '../logsEvent.types'\n\nexport function startLogsBatch(\n  configuration: LogsConfiguration,\n  lifeCycle: LifeCycle,\n  reportError: (message: string) => void,\n  sessionManager: SessionManager\n) {\n  const endpoints = [createEndpointBuilder(configuration, 'logs')]\n  const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'logs')\n  if (replicaEndpoint) {\n    endpoints.push(replicaEndpoint)\n  }\n\n  const batch = createBatch({ endpoints, reportError })\n  sessionManager.expireObservable.subscribe(() => batch.forceFlush('session_expire'))\n\n  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, (serverLogsEvent: LogsEvent & Context) => {\n    batch.add(serverLogsEvent)\n  })\n\n  return batch\n}\n"],"mappings":";;;;AAQA,SAAgB,eACd,eACA,WACA,aACA,gBACA;CACA,MAAM,YAAY,EAAA,GAACA,uCAAAA,sBAAAA,CAAsB,eAAe,MAAM,CAAC;CAC/D,MAAM,mBAAA,GAAkBC,uCAAAA,6BAAAA,CAA6B,eAAe,MAAM;CAC1E,IAAI,iBACF,UAAU,KAAK,eAAe;CAGhC,MAAM,SAAA,GAAQC,kCAAAA,YAAAA,CAAY;EAAE;EAAW;CAAY,CAAC;CACpD,eAAe,iBAAiB,gBAAgB,MAAM,WAAW,gBAAgB,CAAC;CAElF,UAAU,UAAA,IAA6C,oBAAyC;EAC9F,MAAM,IAAI,eAAe;CAC3B,CAAC;CAED,OAAO;AACT"}

package/cjs/transport/startLogsBridge.d.ts

@@ -0,0 +1,2 @@
+import type { LifeCycle } from '../domain/lifeCycle';
+export declare function startLogsBridge(lifeCycle: LifeCycle): void;

package/cjs/transport/startLogsBridge.js

@@ -0,0 +1,13 @@
+require("../domain/lifeCycle.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/transport/startLogsBridge.ts
+function startLogsBridge(lifeCycle) {
+	const bridge = (0, _kubesense_kubesense_browser_core.getEventBridge)();
+	lifeCycle.subscribe(1, (serverLogsEvent) => {
+		bridge.send("log", serverLogsEvent);
+	});
+}
+//#endregion
+exports.startLogsBridge = startLogsBridge;
+
+//# sourceMappingURL=startLogsBridge.js.map

package/cjs/transport/startLogsBridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startLogsBridge.js","names":["getEventBridge"],"sources":["../../src/transport/startLogsBridge.ts"],"sourcesContent":["import type { Context } from '@kubesense/kubesense-browser-core'\nimport { getEventBridge } from '@kubesense/kubesense-browser-core'\nimport type { LifeCycle } from '../domain/lifeCycle'\nimport { LifeCycleEventType } from '../domain/lifeCycle'\nimport type { LogsEvent } from '../logsEvent.types'\n\nexport function startLogsBridge(lifeCycle: LifeCycle) {\n  const bridge = getEventBridge<'log', LogsEvent>()!\n\n  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, (serverLogsEvent: LogsEvent & Context) => {\n    bridge.send('log', serverLogsEvent)\n  })\n}\n"],"mappings":";;;AAMA,SAAgB,gBAAgB,WAAsB;CACpD,MAAM,UAAA,GAASA,kCAAAA,eAAAA,CAAiC;CAEhD,UAAU,UAAA,IAA6C,oBAAyC;EAC9F,OAAO,KAAK,OAAO,eAAe;CACpC,CAAC;AACH"}