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

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

@@ -0,0 +1 @@
+{"version":3,"file":"trackingConsentContext.mjs","names":[],"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,OAAO;EAGT,OAAO;CACT;CAEA,MAAM,sBAAsB,SAAS,WAAW;CAChD,MAAM,kBAAkB,SAAS,WAAW;AAC9C"}

package/esm/domain/createErrorFieldFromRawError.mjs

@@ -0,0 +1,15 @@
+//#region src/domain/createErrorFieldFromRawError.ts
+function createErrorFieldFromRawError(rawError, { includeMessage = false } = {}) {
+	return {
+		stack: rawError.stack,
+		kind: rawError.type,
+		message: includeMessage ? rawError.message : void 0,
+		causes: rawError.causes,
+		fingerprint: rawError.fingerprint,
+		handling: rawError.handling
+	};
+}
+//#endregion
+export { createErrorFieldFromRawError };
+
+//# sourceMappingURL=createErrorFieldFromRawError.mjs.map

package/esm/domain/createErrorFieldFromRawError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createErrorFieldFromRawError.mjs","names":[],"sources":["../../src/domain/createErrorFieldFromRawError.ts"],"sourcesContent":["import type { RawError } from '@kubesense/kubesense-browser-core'\nimport type { RawLoggerLogsEvent } from '../rawLogsEvent.types'\n\nexport function createErrorFieldFromRawError(\n  rawError: RawError,\n  {\n    /**\n     * Set this to `true` to include the error message in the error field. In most cases, the error\n     * message is already included in the log message, so we don't need to include it again.\n     */\n    includeMessage = false,\n  } = {}\n): NonNullable<RawLoggerLogsEvent['error']> {\n  return {\n    stack: rawError.stack,\n    kind: rawError.type,\n    message: includeMessage ? rawError.message : undefined,\n    causes: rawError.causes,\n    fingerprint: rawError.fingerprint,\n    handling: rawError.handling,\n  }\n}\n"],"mappings":";AAGA,SAAgB,6BACd,UACA,EAKE,iBAAiB,UACf,CAAC,GACqC;CAC1C,OAAO;EACL,OAAO,SAAS;EAChB,MAAM,SAAS;EACf,SAAS,iBAAiB,SAAS,UAAU,KAAA;EAC7C,QAAQ,SAAS;EACjB,aAAa,SAAS;EACtB,UAAU,SAAS;CACrB;AACF"}

package/esm/domain/hooks.mjs

@@ -0,0 +1,13 @@
+import { createHook } from "@kubesense/kubesense-js-core/assembly";
+//#region src/domain/hooks.ts
+function createHooks() {
+	return {
+		assembleEventDefaults: createHook(),
+		assembleTelemetry: createHook(),
+		assembleEvent: createHook()
+	};
+}
+//#endregion
+export { createHooks };
+
+//# sourceMappingURL=hooks.mjs.map

package/esm/domain/hooks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.mjs","names":[],"sources":["../../src/domain/hooks.ts"],"sourcesContent":["import type { RelativeTime } from '@kubesense/kubesense-js-core/time'\nimport type { TelemetryEvent } from '@kubesense/kubesense-browser-core'\nimport { createHook } from '@kubesense/kubesense-js-core/assembly'\nimport type { Hook } from '@kubesense/kubesense-js-core/assembly'\nimport type { RecursivePartial } from '@kubesense/kubesense-js-core/util'\nimport type { LogsEvent } from '../logsEvent.types'\nimport type { RawLogsEvent } from '../rawLogsEvent.types'\nimport type { LogsEventDomainContext } from '../domainContext.types'\n\nexport type DefaultLogsEventAttributes = RecursivePartial<LogsEvent>\nexport type DefaultTelemetryEventAttributes = RecursivePartial<TelemetryEvent>\n\ntype DeepReadonly<T> = {\n  readonly [K in keyof T]: DeepReadonly<T[K]>\n}\n\n// Use readonly and DeepReadonly to prevent assemble hook callbacks from mutating the inputs.\n// DeepReadonly is only applied to objects rather than the entire AssembleHookParams to avoid casts for primitives.\nexport interface AssembleHookParams {\n  readonly startTime: RelativeTime\n  rawLogsEvent: DeepReadonly<RawLogsEvent>\n  domainContext: DeepReadonly<LogsEventDomainContext>\n}\n\nexport type AssembleHook = Hook<AssembleHookParams, DefaultLogsEventAttributes>\nexport type AssembleTelemetryHook = Hook<{ startTime: RelativeTime }, DefaultTelemetryEventAttributes>\n\nexport interface Hooks {\n  assembleEventDefaults: AssembleHook\n  assembleTelemetry: AssembleTelemetryHook\n  assembleEvent: AssembleHook\n}\n\nexport function createHooks(): Hooks {\n  return {\n    assembleEventDefaults: createHook(),\n    assembleTelemetry: createHook(),\n    assembleEvent: createHook(),\n  }\n}\n"],"mappings":";;AAiCA,SAAgB,cAAqB;CACnC,OAAO;EACL,uBAAuB,WAAW;EAClC,mBAAmB,WAAW;EAC9B,eAAe,WAAW;CAC5B;AACF"}

package/esm/domain/lifeCycle.mjs

@@ -0,0 +1,7 @@
+import { AbstractLifeCycle } from "@kubesense/kubesense-browser-core";
+//#region src/domain/lifeCycle.ts
+const LifeCycle = AbstractLifeCycle;
+//#endregion
+export { LifeCycle };
+
+//# sourceMappingURL=lifeCycle.mjs.map

package/esm/domain/lifeCycle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeCycle.mjs","names":[],"sources":["../../src/domain/lifeCycle.ts"],"sourcesContent":["import { AbstractLifeCycle } from '@kubesense/kubesense-browser-core'\nimport type { Context } from '@kubesense/kubesense-browser-core'\nimport type { LogsEvent } from '../logsEvent.types'\nimport type { CommonContext, RawLogsEvent } from '../rawLogsEvent.types'\nimport type { LogsEventDomainContext } from '../domainContext.types'\n\nexport const enum LifeCycleEventType {\n  RAW_LOG_COLLECTED,\n  LOG_COLLECTED,\n}\n\ninterface LifeCycleEventMap {\n  [LifeCycleEventType.RAW_LOG_COLLECTED]: RawLogsEventCollectedData\n  [LifeCycleEventType.LOG_COLLECTED]: LogsEvent & Context\n}\n\nexport const LifeCycle = AbstractLifeCycle<LifeCycleEventMap>\nexport type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>\n\nexport interface RawLogsEventCollectedData<E extends RawLogsEvent = RawLogsEvent> {\n  rawLogsEvent: E\n  savedCommonContext?: CommonContext\n  domainContext?: LogsEventDomainContext<E['origin']>\n  ktags?: string[]\n}\n"],"mappings":";;AAgBA,MAAa,YAAY"}

package/esm/domain/logger/isAuthorized.mjs

@@ -0,0 +1,32 @@
+//#region src/domain/logger/isAuthorized.ts
+function isAuthorized(status, handlerType, logger) {
+	const loggerHandler = logger.getHandler();
+	const sanitizedHandlerType = Array.isArray(loggerHandler) ? loggerHandler : [loggerHandler];
+	return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && sanitizedHandlerType.includes(handlerType);
+}
+const StatusType = {
+	ok: "ok",
+	debug: "debug",
+	info: "info",
+	notice: "notice",
+	warn: "warn",
+	error: "error",
+	critical: "critical",
+	alert: "alert",
+	emerg: "emerg"
+};
+const STATUS_PRIORITIES = {
+	[StatusType.ok]: 0,
+	[StatusType.debug]: 1,
+	[StatusType.info]: 2,
+	[StatusType.notice]: 4,
+	[StatusType.warn]: 5,
+	[StatusType.error]: 6,
+	[StatusType.critical]: 7,
+	[StatusType.alert]: 8,
+	[StatusType.emerg]: 9
+};
+//#endregion
+export { STATUS_PRIORITIES, StatusType, isAuthorized };
+
+//# sourceMappingURL=isAuthorized.mjs.map

package/esm/domain/logger/isAuthorized.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAuthorized.mjs","names":[],"sources":["../../../src/domain/logger/isAuthorized.ts"],"sourcesContent":["import type { Logger, HandlerType } from '../logger'\n\nexport function isAuthorized(status: StatusType, handlerType: HandlerType, logger: Logger) {\n  const loggerHandler = logger.getHandler()\n  const sanitizedHandlerType = Array.isArray(loggerHandler) ? loggerHandler : [loggerHandler]\n  return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && sanitizedHandlerType.includes(handlerType)\n}\n\nexport const StatusType = {\n  ok: 'ok',\n  debug: 'debug',\n  info: 'info',\n  notice: 'notice',\n  warn: 'warn',\n  error: 'error',\n  critical: 'critical',\n  alert: 'alert',\n  emerg: 'emerg',\n} as const\n\nexport const STATUS_PRIORITIES: { [key in StatusType]: number } = {\n  [StatusType.ok]: 0,\n  [StatusType.debug]: 1,\n  [StatusType.info]: 2,\n  [StatusType.notice]: 4,\n  [StatusType.warn]: 5,\n  [StatusType.error]: 6,\n  [StatusType.critical]: 7,\n  [StatusType.alert]: 8,\n  [StatusType.emerg]: 9,\n}\n\nexport type StatusType = (typeof StatusType)[keyof typeof StatusType]\n"],"mappings":";AAEA,SAAgB,aAAa,QAAoB,aAA0B,QAAgB;CACzF,MAAM,gBAAgB,OAAO,WAAW;CACxC,MAAM,uBAAuB,MAAM,QAAQ,aAAa,IAAI,gBAAgB,CAAC,aAAa;CAC1F,OAAO,kBAAkB,WAAW,kBAAkB,OAAO,SAAS,MAAM,qBAAqB,SAAS,WAAW;AACvH;AAEA,MAAa,aAAa;CACxB,IAAI;CACJ,OAAO;CACP,MAAM;CACN,QAAQ;CACR,MAAM;CACN,OAAO;CACP,UAAU;CACV,OAAO;CACP,OAAO;AACT;AAEA,MAAa,oBAAqD;EAC/D,WAAW,KAAK;EAChB,WAAW,QAAQ;EACnB,WAAW,OAAO;EAClB,WAAW,SAAS;EACpB,WAAW,OAAO;EAClB,WAAW,QAAQ;EACnB,WAAW,WAAW;EACtB,WAAW,QAAQ;EACnB,WAAW,QAAQ;AACtB"}

package/esm/domain/logger/loggerCollection.mjs

@@ -0,0 +1,47 @@
+import { StatusType, isAuthorized } from "./isAuthorized.mjs";
+import { HandlerType } from "../logger.mjs";
+import "../lifeCycle.mjs";
+import { ConsoleApiName, combine, globalConsole, originalConsoleMethods } from "@kubesense/kubesense-js-core/util";
+import { ErrorSource } from "@kubesense/kubesense-browser-core";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/logger/loggerCollection.ts
+function startLoggerCollection(lifeCycle) {
+	function handleLog(logsMessage, logger, handlingStack, savedCommonContext, savedDate) {
+		const messageContext = combine(logger.getContext(), logsMessage.context);
+		if (isAuthorized(logsMessage.status, HandlerType.console, logger)) displayInConsole(logsMessage, messageContext);
+		if (isAuthorized(logsMessage.status, HandlerType.http, logger)) {
+			const rawLogEventData = {
+				rawLogsEvent: combine({
+					date: savedDate || timeStampNow(),
+					message: logsMessage.message,
+					status: logsMessage.status,
+					origin: ErrorSource.LOGGER,
+					_kubesense: { debug_ids: logsMessage.debugIds }
+				}, messageContext),
+				savedCommonContext,
+				ktags: logger.getTags()
+			};
+			if (handlingStack) rawLogEventData.domainContext = { handlingStack };
+			lifeCycle.notify(0, rawLogEventData);
+		}
+	}
+	return { handleLog };
+}
+const loggerToConsoleApiName = {
+	[StatusType.ok]: ConsoleApiName.debug,
+	[StatusType.debug]: ConsoleApiName.debug,
+	[StatusType.info]: ConsoleApiName.info,
+	[StatusType.notice]: ConsoleApiName.info,
+	[StatusType.warn]: ConsoleApiName.warn,
+	[StatusType.error]: ConsoleApiName.error,
+	[StatusType.critical]: ConsoleApiName.error,
+	[StatusType.alert]: ConsoleApiName.error,
+	[StatusType.emerg]: ConsoleApiName.error
+};
+function displayInConsole({ status, message }, messageContext) {
+	originalConsoleMethods[loggerToConsoleApiName[status]].call(globalConsole, message, messageContext);
+}
+//#endregion
+export { startLoggerCollection };
+
+//# sourceMappingURL=loggerCollection.mjs.map

package/esm/domain/logger/loggerCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loggerCollection.mjs","names":[],"sources":["../../../src/domain/logger/loggerCollection.ts"],"sourcesContent":["import { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport type { Context } from '@kubesense/kubesense-browser-core'\nimport { ErrorSource } from '@kubesense/kubesense-browser-core'\nimport { originalConsoleMethods, globalConsole, ConsoleApiName, combine } from '@kubesense/kubesense-js-core/util'\nimport type { CommonContext, RawLogsEvent } from '../../rawLogsEvent.types'\nimport type { LifeCycle, RawLogsEventCollectedData } from '../lifeCycle'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport type { Logger, LogsMessage } from '../logger'\nimport { HandlerType } from '../logger'\nimport { isAuthorized, StatusType } from './isAuthorized'\n\nexport function startLoggerCollection(lifeCycle: LifeCycle) {\n  function handleLog(\n    logsMessage: LogsMessage,\n    logger: Logger,\n    handlingStack?: string,\n    savedCommonContext?: CommonContext,\n    savedDate?: TimeStamp\n  ) {\n    const messageContext = combine(logger.getContext(), logsMessage.context)\n\n    if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {\n      displayInConsole(logsMessage, messageContext)\n    }\n\n    if (isAuthorized(logsMessage.status, HandlerType.http, logger)) {\n      const rawLogEventData: RawLogsEventCollectedData<RawLogsEvent> = {\n        rawLogsEvent: combine(\n          {\n            date: savedDate || timeStampNow(),\n            message: logsMessage.message,\n            status: logsMessage.status,\n            origin: ErrorSource.LOGGER,\n            _kubesense: { debug_ids: logsMessage.debugIds },\n          },\n          messageContext\n        ),\n        savedCommonContext,\n        ktags: logger.getTags(),\n      }\n\n      if (handlingStack) {\n        rawLogEventData.domainContext = { handlingStack }\n      }\n\n      lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, rawLogEventData)\n    }\n  }\n\n  return {\n    handleLog,\n  }\n}\nconst loggerToConsoleApiName: { [key in StatusType]: ConsoleApiName } = {\n  [StatusType.ok]: ConsoleApiName.debug,\n  [StatusType.debug]: ConsoleApiName.debug,\n  [StatusType.info]: ConsoleApiName.info,\n  [StatusType.notice]: ConsoleApiName.info,\n  [StatusType.warn]: ConsoleApiName.warn,\n  [StatusType.error]: ConsoleApiName.error,\n  [StatusType.critical]: ConsoleApiName.error,\n  [StatusType.alert]: ConsoleApiName.error,\n  [StatusType.emerg]: ConsoleApiName.error,\n}\n\nfunction displayInConsole({ status, message }: LogsMessage, messageContext: Context | undefined) {\n  originalConsoleMethods[loggerToConsoleApiName[status]].call(globalConsole, message, messageContext)\n}\n"],"mappings":";;;;;;;AAYA,SAAgB,sBAAsB,WAAsB;CAC1D,SAAS,UACP,aACA,QACA,eACA,oBACA,WACA;EACA,MAAM,iBAAiB,QAAQ,OAAO,WAAW,GAAG,YAAY,OAAO;EAEvE,IAAI,aAAa,YAAY,QAAQ,YAAY,SAAS,MAAM,GAC9D,iBAAiB,aAAa,cAAc;EAG9C,IAAI,aAAa,YAAY,QAAQ,YAAY,MAAM,MAAM,GAAG;GAC9D,MAAM,kBAA2D;IAC/D,cAAc,QACZ;KACE,MAAM,aAAa,aAAa;KAChC,SAAS,YAAY;KACrB,QAAQ,YAAY;KACpB,QAAQ,YAAY;KACpB,YAAY,EAAE,WAAW,YAAY,SAAS;IAChD,GACA,cACF;IACA;IACA,OAAO,OAAO,QAAQ;GACxB;GAEA,IAAI,eACF,gBAAgB,gBAAgB,EAAE,cAAc;GAGlD,UAAU,OAAA,GAA6C,eAAe;EACxE;CACF;CAEA,OAAO,EACL,UACF;AACF;AACA,MAAM,yBAAkE;EACrE,WAAW,KAAK,eAAe;EAC/B,WAAW,QAAQ,eAAe;EAClC,WAAW,OAAO,eAAe;EACjC,WAAW,SAAS,eAAe;EACnC,WAAW,OAAO,eAAe;EACjC,WAAW,QAAQ,eAAe;EAClC,WAAW,WAAW,eAAe;EACrC,WAAW,QAAQ,eAAe;EAClC,WAAW,QAAQ,eAAe;AACrC;AAEA,SAAS,iBAAiB,EAAE,QAAQ,WAAwB,gBAAqC;CAC/F,uBAAuB,uBAAuB,QAAQ,CAAC,KAAK,eAAe,SAAS,cAAc;AACpG"}

package/esm/domain/logger.mjs

@@ -0,0 +1,110 @@
+import { StatusType, isAuthorized } from "./logger/isAuthorized.mjs";
+import { createErrorFieldFromRawError } from "./createErrorFieldFromRawError.mjs";
+import { combine } from "@kubesense/kubesense-js-core/util";
+import { ErrorHandling, ErrorSource, NonErrorPrefix, buildTag, computeRawError, createContextManager, createHandlingStack, sanitize, sanitizeTag } from "@kubesense/kubesense-browser-core";
+import { callMonitored } from "@kubesense/kubesense-js-core/monitor";
+import { clocksNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/logger.ts
+const HandlerType = {
+	console: "console",
+	http: "http",
+	silent: "silent"
+};
+const STATUSES = Object.keys(StatusType);
+var Logger = class {
+	constructor(handleLogStrategy, name, handlerType = HandlerType.http, level = StatusType.debug, loggerContext = {}) {
+		this.handleLogStrategy = handleLogStrategy;
+		this.handlerType = handlerType;
+		this.level = level;
+		this.contextManager = createContextManager("logger");
+		this.tags = [];
+		this.contextManager.setContext(loggerContext);
+		if (name) this.contextManager.setContextProperty("logger", { name });
+	}
+	logImplementation(message, messageContext, status = StatusType.info, error, handlingStack) {
+		callMonitored(() => {
+			const sanitizedMessageContext = sanitize(messageContext);
+			let context;
+			let debugIds;
+			if (error !== void 0 && error !== null) {
+				const rawError = computeRawError({
+					originalError: error,
+					nonErrorPrefix: NonErrorPrefix.PROVIDED,
+					source: ErrorSource.LOGGER,
+					handling: ErrorHandling.HANDLED,
+					startClocks: clocksNow()
+				});
+				debugIds = rawError.debugIds;
+				context = combine({ error: createErrorFieldFromRawError(rawError, { includeMessage: true }) }, rawError.context, sanitizedMessageContext);
+			} else context = sanitizedMessageContext;
+			this.handleLogStrategy({
+				message: sanitize(message),
+				context,
+				status,
+				...debugIds ? { debugIds } : {}
+			}, this, handlingStack);
+		});
+	}
+	log(message, messageContext, status = StatusType.info, error) {
+		let handlingStack;
+		if (isAuthorized(status, HandlerType.http, this)) handlingStack = createHandlingStack("log");
+		this.logImplementation(message, messageContext, status, error, handlingStack);
+	}
+	setContext(context) {
+		this.contextManager.setContext(context);
+	}
+	getContext() {
+		return this.contextManager.getContext();
+	}
+	setContextProperty(key, value) {
+		this.contextManager.setContextProperty(key, value);
+	}
+	removeContextProperty(key) {
+		this.contextManager.removeContextProperty(key);
+	}
+	clearContext() {
+		this.contextManager.clearContext();
+	}
+	addTag(key, value) {
+		this.tags.push(buildTag(key, value));
+	}
+	removeTagsWithKey(key) {
+		const sanitizedKey = sanitizeTag(key);
+		this.tags = this.tags.filter((tag) => tag !== sanitizedKey && !tag.startsWith(`${sanitizedKey}:`));
+	}
+	getTags() {
+		return this.tags.slice();
+	}
+	setHandler(handler) {
+		this.handlerType = handler;
+	}
+	getHandler() {
+		return this.handlerType;
+	}
+	setLevel(level) {
+		this.level = level;
+	}
+	getLevel() {
+		return this.level;
+	}
+};
+Logger.prototype.ok = createLoggerMethod(StatusType.ok);
+Logger.prototype.debug = createLoggerMethod(StatusType.debug);
+Logger.prototype.info = createLoggerMethod(StatusType.info);
+Logger.prototype.notice = createLoggerMethod(StatusType.notice);
+Logger.prototype.warn = createLoggerMethod(StatusType.warn);
+Logger.prototype.error = createLoggerMethod(StatusType.error);
+Logger.prototype.critical = createLoggerMethod(StatusType.critical);
+Logger.prototype.alert = createLoggerMethod(StatusType.alert);
+Logger.prototype.emerg = createLoggerMethod(StatusType.emerg);
+function createLoggerMethod(status) {
+	return function(message, messageContext, error) {
+		let handlingStack;
+		if (isAuthorized(status, HandlerType.http, this)) handlingStack = createHandlingStack("log");
+		this.logImplementation(message, messageContext, status, error, handlingStack);
+	};
+}
+//#endregion
+export { HandlerType, Logger, STATUSES };
+
+//# sourceMappingURL=logger.mjs.map

package/esm/domain/logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":[],"sources":["../../src/domain/logger.ts"],"sourcesContent":["import type { Context, ContextManager, DebugIdEntry } from '@kubesense/kubesense-browser-core'\nimport { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { combine } from '@kubesense/kubesense-js-core/util'\nimport {\n  computeRawError,\n  ErrorHandling,\n  createContextManager,\n  ErrorSource,\n  sanitize,\n  NonErrorPrefix,\n  createHandlingStack,\n  buildTag,\n  sanitizeTag,\n} from '@kubesense/kubesense-browser-core'\nimport { callMonitored } from '@kubesense/kubesense-js-core/monitor'\n\nimport { isAuthorized, StatusType } from './logger/isAuthorized'\nimport { createErrorFieldFromRawError } from './createErrorFieldFromRawError'\n\nexport interface LogsMessage {\n  message: string\n  status: StatusType\n  context?: Context\n  debugIds?: DebugIdEntry[]\n}\n\nexport const HandlerType = {\n  console: 'console',\n  http: 'http',\n  silent: 'silent',\n} as const\n\nexport type HandlerType = (typeof HandlerType)[keyof typeof HandlerType]\nexport const STATUSES = Object.keys(StatusType) as StatusType[]\n\n// note: it is safe to merge declarations as long as the methods are actually defined on the prototype\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging, no-restricted-syntax\nexport class Logger {\n  private contextManager: ContextManager\n\n  // Tags are formatted as either `key:value` or `key_only`\n  private tags: string[]\n\n  constructor(\n    private handleLogStrategy: (logsMessage: LogsMessage, logger: Logger, handlingStack?: string) => void,\n    name?: string,\n    private handlerType: HandlerType | HandlerType[] = HandlerType.http,\n    private level: StatusType = StatusType.debug,\n    loggerContext: object = {}\n  ) {\n    this.contextManager = createContextManager('logger')\n    this.tags = []\n    this.contextManager.setContext(loggerContext)\n    if (name) {\n      this.contextManager.setContextProperty('logger', { name })\n    }\n  }\n\n  logImplementation(\n    message: string,\n    messageContext?: object,\n    status: StatusType = StatusType.info,\n    error?: Error,\n    handlingStack?: string\n  ) {\n    callMonitored(() => {\n      const sanitizedMessageContext = sanitize(messageContext) as Context\n      let context: Context\n      let debugIds: DebugIdEntry[] | undefined\n\n      if (error !== undefined && error !== null) {\n        const rawError = computeRawError({\n          originalError: error,\n          nonErrorPrefix: NonErrorPrefix.PROVIDED,\n          source: ErrorSource.LOGGER,\n          handling: ErrorHandling.HANDLED,\n          startClocks: clocksNow(),\n        })\n\n        debugIds = rawError.debugIds\n        context = combine(\n          {\n            error: createErrorFieldFromRawError(rawError, { includeMessage: true }),\n          },\n          rawError.context,\n          sanitizedMessageContext\n        )\n      } else {\n        context = sanitizedMessageContext\n      }\n\n      this.handleLogStrategy(\n        {\n          message: sanitize(message)!,\n          context,\n          status,\n          ...(debugIds ? { debugIds } : {}),\n        },\n        this,\n        handlingStack\n      )\n    })\n  }\n\n  log(message: string, messageContext?: object, status: StatusType = StatusType.info, error?: Error) {\n    let handlingStack: string | undefined\n\n    if (isAuthorized(status, HandlerType.http, this)) {\n      handlingStack = createHandlingStack('log')\n    }\n\n    this.logImplementation(message, messageContext, status, error, handlingStack)\n  }\n\n  setContext(context: object) {\n    this.contextManager.setContext(context)\n  }\n\n  getContext() {\n    return this.contextManager.getContext()\n  }\n\n  setContextProperty(key: string, value: any) {\n    this.contextManager.setContextProperty(key, value)\n  }\n\n  removeContextProperty(key: string) {\n    this.contextManager.removeContextProperty(key)\n  }\n\n  clearContext() {\n    this.contextManager.clearContext()\n  }\n\n  addTag(key: string, value?: string) {\n    this.tags.push(buildTag(key, value))\n  }\n\n  removeTagsWithKey(key: string) {\n    const sanitizedKey = sanitizeTag(key)\n\n    this.tags = this.tags.filter((tag) => tag !== sanitizedKey && !tag.startsWith(`${sanitizedKey}:`))\n  }\n\n  getTags() {\n    return this.tags.slice()\n  }\n\n  setHandler(handler: HandlerType | HandlerType[]) {\n    this.handlerType = handler\n  }\n\n  getHandler() {\n    return this.handlerType\n  }\n\n  setLevel(level: StatusType) {\n    this.level = level\n  }\n\n  getLevel() {\n    return this.level\n  }\n}\n\n/* eslint-disable local-rules/disallow-side-effects */\nLogger.prototype.ok = createLoggerMethod(StatusType.ok)\nLogger.prototype.debug = createLoggerMethod(StatusType.debug)\nLogger.prototype.info = createLoggerMethod(StatusType.info)\nLogger.prototype.notice = createLoggerMethod(StatusType.notice)\nLogger.prototype.warn = createLoggerMethod(StatusType.warn)\nLogger.prototype.error = createLoggerMethod(StatusType.error)\nLogger.prototype.critical = createLoggerMethod(StatusType.critical)\nLogger.prototype.alert = createLoggerMethod(StatusType.alert)\nLogger.prototype.emerg = createLoggerMethod(StatusType.emerg)\n/* eslint-enable local-rules/disallow-side-effects */\n\n// note: it is safe to merge declarations as long as the methods are actually defined on the prototype\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging\nexport interface Logger {\n  ok(message: string, messageContext?: object, error?: Error): void\n  debug(message: string, messageContext?: object, error?: Error): void\n  info(message: string, messageContext?: object, error?: Error): void\n  notice(message: string, messageContext?: object, error?: Error): void\n  warn(message: string, messageContext?: object, error?: Error): void\n  error(message: string, messageContext?: object, error?: Error): void\n  critical(message: string, messageContext?: object, error?: Error): void\n  alert(message: string, messageContext?: object, error?: Error): void\n  emerg(message: string, messageContext?: object, error?: Error): void\n}\n\nfunction createLoggerMethod(status: StatusType) {\n  return function (this: Logger, message: string, messageContext?: object, error?: Error) {\n    let handlingStack: string | undefined\n\n    if (isAuthorized(status, HandlerType.http, this)) {\n      handlingStack = createHandlingStack('log')\n    }\n\n    this.logImplementation(message, messageContext, status, error, handlingStack)\n  }\n}\n"],"mappings":";;;;;;;AA0BA,MAAa,cAAc;CACzB,SAAS;CACT,MAAM;CACN,QAAQ;AACV;AAGA,MAAa,WAAW,OAAO,KAAK,UAAU;AAI9C,IAAa,SAAb,MAAoB;CAMlB,YACE,mBACA,MACA,cAAmD,YAAY,MAC/D,QAA4B,WAAW,OACvC,gBAAwB,CAAC,GACzB;EALQ,KAAA,oBAAA;EAEA,KAAA,cAAA;EACA,KAAA,QAAA;EAGR,KAAK,iBAAiB,qBAAqB,QAAQ;EACnD,KAAK,OAAO,CAAC;EACb,KAAK,eAAe,WAAW,aAAa;EAC5C,IAAI,MACF,KAAK,eAAe,mBAAmB,UAAU,EAAE,KAAK,CAAC;CAE7D;CAEA,kBACE,SACA,gBACA,SAAqB,WAAW,MAChC,OACA,eACA;EACA,oBAAoB;GAClB,MAAM,0BAA0B,SAAS,cAAc;GACvD,IAAI;GACJ,IAAI;GAEJ,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM;IACzC,MAAM,WAAW,gBAAgB;KAC/B,eAAe;KACf,gBAAgB,eAAe;KAC/B,QAAQ,YAAY;KACpB,UAAU,cAAc;KACxB,aAAa,UAAU;IACzB,CAAC;IAED,WAAW,SAAS;IACpB,UAAU,QACR,EACE,OAAO,6BAA6B,UAAU,EAAE,gBAAgB,KAAK,CAAC,EACxE,GACA,SAAS,SACT,uBACF;GACF,OACE,UAAU;GAGZ,KAAK,kBACH;IACE,SAAS,SAAS,OAAO;IACzB;IACA;IACA,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC;GACjC,GACA,MACA,aACF;EACF,CAAC;CACH;CAEA,IAAI,SAAiB,gBAAyB,SAAqB,WAAW,MAAM,OAAe;EACjG,IAAI;EAEJ,IAAI,aAAa,QAAQ,YAAY,MAAM,IAAI,GAC7C,gBAAgB,oBAAoB,KAAK;EAG3C,KAAK,kBAAkB,SAAS,gBAAgB,QAAQ,OAAO,aAAa;CAC9E;CAEA,WAAW,SAAiB;EAC1B,KAAK,eAAe,WAAW,OAAO;CACxC;CAEA,aAAa;EACX,OAAO,KAAK,eAAe,WAAW;CACxC;CAEA,mBAAmB,KAAa,OAAY;EAC1C,KAAK,eAAe,mBAAmB,KAAK,KAAK;CACnD;CAEA,sBAAsB,KAAa;EACjC,KAAK,eAAe,sBAAsB,GAAG;CAC/C;CAEA,eAAe;EACb,KAAK,eAAe,aAAa;CACnC;CAEA,OAAO,KAAa,OAAgB;EAClC,KAAK,KAAK,KAAK,SAAS,KAAK,KAAK,CAAC;CACrC;CAEA,kBAAkB,KAAa;EAC7B,MAAM,eAAe,YAAY,GAAG;EAEpC,KAAK,OAAO,KAAK,KAAK,QAAQ,QAAQ,QAAQ,gBAAgB,CAAC,IAAI,WAAW,GAAG,aAAa,EAAE,CAAC;CACnG;CAEA,UAAU;EACR,OAAO,KAAK,KAAK,MAAM;CACzB;CAEA,WAAW,SAAsC;EAC/C,KAAK,cAAc;CACrB;CAEA,aAAa;EACX,OAAO,KAAK;CACd;CAEA,SAAS,OAAmB;EAC1B,KAAK,QAAQ;CACf;CAEA,WAAW;EACT,OAAO,KAAK;CACd;AACF;AAGA,OAAO,UAAU,KAAK,mBAAmB,WAAW,EAAE;AACtD,OAAO,UAAU,QAAQ,mBAAmB,WAAW,KAAK;AAC5D,OAAO,UAAU,OAAO,mBAAmB,WAAW,IAAI;AAC1D,OAAO,UAAU,SAAS,mBAAmB,WAAW,MAAM;AAC9D,OAAO,UAAU,OAAO,mBAAmB,WAAW,IAAI;AAC1D,OAAO,UAAU,QAAQ,mBAAmB,WAAW,KAAK;AAC5D,OAAO,UAAU,WAAW,mBAAmB,WAAW,QAAQ;AAClE,OAAO,UAAU,QAAQ,mBAAmB,WAAW,KAAK;AAC5D,OAAO,UAAU,QAAQ,mBAAmB,WAAW,KAAK;AAiB5D,SAAS,mBAAmB,QAAoB;CAC9C,OAAO,SAAwB,SAAiB,gBAAyB,OAAe;EACtF,IAAI;EAEJ,IAAI,aAAa,QAAQ,YAAY,MAAM,IAAI,GAC7C,gBAAgB,oBAAoB,KAAK;EAG3C,KAAK,kBAAkB,SAAS,gBAAgB,QAAQ,OAAO,aAAa;CAC9E;AACF"}

package/esm/domain/networkError/networkErrorCollection.mjs

@@ -0,0 +1,56 @@
+import { StatusType } from "../logger/isAuthorized.mjs";
+import "../lifeCycle.mjs";
+import { BufferedDataType, ErrorSource, ONE_KIBI_BYTE, RequestType, ResponseBodyAction, buildDebugIdByUrl, computeStackTrace, getStackTraceUrls, initFetchObservable, isServerError, noop, safeTruncate, toStackTraceString } from "@kubesense/kubesense-browser-core";
+import { isIntakeUrl } from "@kubesense/kubesense-js-core/transport";
+//#region src/domain/networkError/networkErrorCollection.ts
+/** arbitrary value, byte precision not needed */
+const DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE;
+function startNetworkErrorCollection(configuration, lifeCycle, bufferedDataObservable) {
+	if (!configuration.forwardErrorsToLogs) return { stop: noop };
+	initFetchObservable({ responseBodyAction: (context) => isNetworkError(context) ? ResponseBodyAction.COLLECT : ResponseBodyAction.IGNORE });
+	const subscription = bufferedDataObservable.subscribe(({ data, type }) => {
+		if (type === BufferedDataType.FETCH && data.state === "resolve") handleResponse(RequestType.FETCH, data);
+		else if (type === BufferedDataType.XHR && data.state === "complete") handleResponse(RequestType.XHR, data);
+	});
+	function isNetworkError(request) {
+		return !isIntakeUrl(request.url) && !request.isAborted && (isRejected(request) || isServerError(request.status));
+	}
+	function handleResponse(type, request) {
+		if (!isNetworkError(request)) return;
+		const stackTrace = "error" in request && request.error ? computeStackTrace(request.error) : void 0;
+		const stack = stackTrace ? toStackTraceString(stackTrace) : request.responseBody || "Failed to load";
+		const debugIds = stackTrace ? buildDebugIdByUrl(getStackTraceUrls(stackTrace)) : void 0;
+		const domainContext = { handlingStack: request.handlingStack };
+		lifeCycle.notify(0, {
+			rawLogsEvent: {
+				message: `${format(type)} error ${request.method} ${request.url}`,
+				date: request.startClocks.timeStamp,
+				error: {
+					stack: safeTruncate(stack, DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT, "..."),
+					handling: void 0
+				},
+				_kubesense: { debug_ids: debugIds },
+				http: {
+					method: request.method,
+					status_code: request.status,
+					url: request.url
+				},
+				status: StatusType.error,
+				origin: ErrorSource.NETWORK
+			},
+			domainContext
+		});
+	}
+	return { stop: () => subscription.unsubscribe() };
+}
+function isRejected(request) {
+	return request.status === 0 && request.responseType !== "opaque";
+}
+function format(type) {
+	if (RequestType.XHR === type) return "XHR";
+	return "Fetch";
+}
+//#endregion
+export { DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT, startNetworkErrorCollection };
+
+//# sourceMappingURL=networkErrorCollection.mjs.map

package/esm/domain/networkError/networkErrorCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkErrorCollection.mjs","names":[],"sources":["../../../src/domain/networkError/networkErrorCollection.ts"],"sourcesContent":["import type {\n  FetchResolveContext,\n  XhrCompleteContext,\n  Observable,\n  BufferedData,\n} from '@kubesense/kubesense-browser-core'\nimport {\n  BufferedDataType,\n  ErrorSource,\n  RequestType,\n  initFetchObservable,\n  computeStackTrace,\n  toStackTraceString,\n  noop,\n  isServerError,\n  ResponseBodyAction,\n  safeTruncate,\n  ONE_KIBI_BYTE,\n  buildDebugIdByUrl,\n  getStackTraceUrls,\n} from '@kubesense/kubesense-browser-core'\nimport { isIntakeUrl } from '@kubesense/kubesense-js-core/transport'\nimport type { LogsConfiguration } from '../configuration'\n\n/** arbitrary value, byte precision not needed */\nexport const DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE\nimport type { LifeCycle } from '../lifeCycle'\nimport type { LogsEventDomainContext } from '../../domainContext.types'\nimport { LifeCycleEventType } from '../lifeCycle'\nimport { StatusType } from '../logger/isAuthorized'\n\nexport function startNetworkErrorCollection(\n  configuration: LogsConfiguration,\n  lifeCycle: LifeCycle,\n  bufferedDataObservable: Observable<BufferedData>\n) {\n  if (!configuration.forwardErrorsToLogs) {\n    return { stop: noop }\n  }\n\n  // Register responseBodyAction getter (no subscription needed)\n  initFetchObservable({\n    responseBodyAction: (context) => (isNetworkError(context) ? ResponseBodyAction.COLLECT : ResponseBodyAction.IGNORE),\n  })\n\n  const subscription = bufferedDataObservable.subscribe(({ data, type }) => {\n    if (type === BufferedDataType.FETCH && data.state === 'resolve') {\n      handleResponse(RequestType.FETCH, data)\n    } else if (type === BufferedDataType.XHR && data.state === 'complete') {\n      handleResponse(RequestType.XHR, data)\n    }\n  })\n\n  function isNetworkError(request: XhrCompleteContext | FetchResolveContext) {\n    return !isIntakeUrl(request.url) && !request.isAborted && (isRejected(request) || isServerError(request.status))\n  }\n\n  function handleResponse(type: RequestType, request: XhrCompleteContext | FetchResolveContext) {\n    if (!isNetworkError(request)) {\n      return\n    }\n    const stackTrace = 'error' in request && request.error ? computeStackTrace(request.error) : undefined\n    const stack = stackTrace ? toStackTraceString(stackTrace) : request.responseBody || 'Failed to load'\n    const debugIds = stackTrace ? buildDebugIdByUrl(getStackTraceUrls(stackTrace)) : undefined\n\n    const domainContext: LogsEventDomainContext<typeof ErrorSource.NETWORK> = {\n      handlingStack: request.handlingStack,\n    }\n\n    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {\n      rawLogsEvent: {\n        message: `${format(type)} error ${request.method} ${request.url}`,\n        date: request.startClocks.timeStamp,\n        error: {\n          stack: safeTruncate(stack, DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT, '...'),\n          // We don't know if the error was handled or not, so we set it to undefined\n          handling: undefined,\n        },\n        _kubesense: { debug_ids: debugIds },\n        http: {\n          method: request.method as any, // Cast resource method because of case mismatch cf issue RUMF-1152\n          status_code: request.status,\n          url: request.url,\n        },\n        status: StatusType.error,\n        origin: ErrorSource.NETWORK,\n      },\n      domainContext,\n    })\n  }\n\n  return { stop: () => subscription.unsubscribe() }\n}\n\nfunction isRejected(request: { status: number; responseType?: string }) {\n  return request.status === 0 && request.responseType !== 'opaque'\n}\n\nfunction format(type: RequestType) {\n  if (RequestType.XHR === type) {\n    return 'XHR'\n  }\n  return 'Fetch'\n}\n"],"mappings":";;;;;;AAyBA,MAAa,8CAA8C,KAAK;AAMhE,SAAgB,4BACd,eACA,WACA,wBACA;CACA,IAAI,CAAC,cAAc,qBACjB,OAAO,EAAE,MAAM,KAAK;CAItB,oBAAoB,EAClB,qBAAqB,YAAa,eAAe,OAAO,IAAI,mBAAmB,UAAU,mBAAmB,OAC9G,CAAC;CAED,MAAM,eAAe,uBAAuB,WAAW,EAAE,MAAM,WAAW;EACxE,IAAI,SAAS,iBAAiB,SAAS,KAAK,UAAU,WACpD,eAAe,YAAY,OAAO,IAAI;OACjC,IAAI,SAAS,iBAAiB,OAAO,KAAK,UAAU,YACzD,eAAe,YAAY,KAAK,IAAI;CAExC,CAAC;CAED,SAAS,eAAe,SAAmD;EACzE,OAAO,CAAC,YAAY,QAAQ,GAAG,KAAK,CAAC,QAAQ,cAAc,WAAW,OAAO,KAAK,cAAc,QAAQ,MAAM;CAChH;CAEA,SAAS,eAAe,MAAmB,SAAmD;EAC5F,IAAI,CAAC,eAAe,OAAO,GACzB;EAEF,MAAM,aAAa,WAAW,WAAW,QAAQ,QAAQ,kBAAkB,QAAQ,KAAK,IAAI,KAAA;EAC5F,MAAM,QAAQ,aAAa,mBAAmB,UAAU,IAAI,QAAQ,gBAAgB;EACpF,MAAM,WAAW,aAAa,kBAAkB,kBAAkB,UAAU,CAAC,IAAI,KAAA;EAEjF,MAAM,gBAAoE,EACxE,eAAe,QAAQ,cACzB;EAEA,UAAU,OAAA,GAA6C;GACrD,cAAc;IACZ,SAAS,GAAG,OAAO,IAAI,EAAE,SAAS,QAAQ,OAAO,GAAG,QAAQ;IAC5D,MAAM,QAAQ,YAAY;IAC1B,OAAO;KACL,OAAO,aAAa,OAAO,6CAA6C,KAAK;KAE7E,UAAU,KAAA;IACZ;IACA,YAAY,EAAE,WAAW,SAAS;IAClC,MAAM;KACJ,QAAQ,QAAQ;KAChB,aAAa,QAAQ;KACrB,KAAK,QAAQ;IACf;IACA,QAAQ,WAAW;IACnB,QAAQ,YAAY;GACtB;GACA;EACF,CAAC;CACH;CAEA,OAAO,EAAE,YAAY,aAAa,YAAY,EAAE;AAClD;AAEA,SAAS,WAAW,SAAoD;CACtE,OAAO,QAAQ,WAAW,KAAK,QAAQ,iBAAiB;AAC1D;AAEA,SAAS,OAAO,MAAmB;CACjC,IAAI,YAAY,QAAQ,MACtB,OAAO;CAET,OAAO;AACT"}

package/esm/domain/plugins.mjs

@@ -0,0 +1,12 @@
+//#region src/domain/plugins.ts
+function callPluginsMethod(plugins, methodName, parameter) {
+	if (!plugins) return;
+	for (const plugin of plugins) {
+		const method = plugin[methodName];
+		if (method) method(parameter);
+	}
+}
+//#endregion
+export { callPluginsMethod };
+
+//# sourceMappingURL=plugins.mjs.map

package/esm/domain/plugins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.mjs","names":[],"sources":["../../src/domain/plugins.ts"],"sourcesContent":["import type { LogsPublicApi } from '../boot/logsPublicApi'\nimport type { StartLogsResult } from '../boot/startLogs'\nimport type { LogsInitConfiguration } from './configuration'\nimport type { AssembleHook } from './hooks'\n\n/**\n * onInit plugin API options.\n *\n * @experimental\n */\nexport interface OnInitOptions {\n  initConfiguration: LogsInitConfiguration\n  publicApi: LogsPublicApi\n  /**\n   * Register a callback invoked when a log event is assembled, so plugins can enrich or override\n   * log fields before they are sent. Callbacks registered in `onInit` run before any log is\n   * assembled, including logs buffered during the pre-start phase.\n   */\n  registerAssembleEventHook: AssembleHook['register']\n}\n\n/**\n * onLogsStart plugin API options.\n *\n * @experimental\n */\nexport interface OnLogsStartOptions {\n  /**\n   * Emit a log with the same pipeline as a logger call.\n   */\n  handleLog: StartLogsResult['handleLog']\n}\n\n/**\n * Plugin interface of the Logs browser SDK.\n *\n * 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 */\nexport interface LogsPlugin {\n  name: string\n  getConfigurationTelemetry?(): Record<string, unknown>\n  onInit?(options: OnInitOptions): void\n  onLogsStart?(options: OnLogsStartOptions): void\n}\n\ntype MethodNames = 'onInit' | 'onLogsStart'\ntype MethodParameter<MethodName extends MethodNames> = Parameters<NonNullable<LogsPlugin[MethodName]>>[0]\n\nexport function callPluginsMethod<MethodName extends MethodNames>(\n  plugins: LogsPlugin[] | undefined,\n  methodName: MethodName,\n  parameter: MethodParameter<MethodName>\n): void\nexport function callPluginsMethod<MethodName extends MethodNames>(\n  plugins: LogsPlugin[] | undefined,\n  methodName: MethodName,\n  parameter: any\n) {\n  if (!plugins) {\n    return\n  }\n  for (const plugin of plugins) {\n    const method = plugin[methodName]\n    if (method) {\n      method(parameter)\n    }\n  }\n}\n"],"mappings":";AAyDA,SAAgB,kBACd,SACA,YACA,WACA;CACA,IAAI,CAAC,SACH;CAEF,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,SAAS,OAAO;EACtB,IAAI,QACF,OAAO,SAAS;CAEpB;AACF"}

package/esm/domain/remoteSdkConfiguration.mjs

@@ -0,0 +1,65 @@
+import { ConsoleApiName } from "@kubesense/kubesense-js-core/util";
+import { RawReportType, getCachedSdkConfig, objectValues, readBoolean, readSampleRate, readString, readStringList, refreshSdkConfig } from "@kubesense/kubesense-browser-core";
+//#region src/domain/remoteSdkConfiguration.ts
+function applyCachedLogsSdkConfiguration(initConfiguration) {
+	const remoteConfig = getCachedSdkConfig(initConfiguration.clientToken);
+	if (!remoteConfig) return {
+		initConfiguration,
+		logsEnabled: true
+	};
+	return applyLogsSdkConfiguration(initConfiguration, remoteConfig);
+}
+function applyLogsSdkConfiguration(initConfiguration, remoteConfig) {
+	const features = remoteConfig.features;
+	if (readBoolean(features, "logs") === false) return {
+		initConfiguration,
+		logsEnabled: false
+	};
+	const logs = remoteConfig.logs;
+	if (!logs) return {
+		initConfiguration,
+		logsEnabled: true
+	};
+	const applied = { ...initConfiguration };
+	assign(applied, "sessionSampleRate", readSampleRate(logs, "sessionSampleRate"));
+	assign(applied, "telemetrySampleRate", readSampleRate(logs, "telemetrySampleRate"));
+	assign(applied, "forwardErrorsToLogs", readBoolean(logs, "forwardErrorsToLogs"));
+	assign(applied, "trackAnonymousUser", readBoolean(logs, "trackAnonymousUser"));
+	assign(applied, "trackSessionAcrossSubdomains", readBoolean(logs, "trackSessionAcrossSubdomains"));
+	assign(applied, "allowedTrackingOrigins", readStringList(logs.allowedTrackingOrigins));
+	assign(applied, "forwardConsoleLogs", readForwardList(logs.forwardConsoleLogs, objectValues(ConsoleApiName)));
+	assign(applied, "forwardReports", readForwardList(logs.forwardReports, objectValues(RawReportType)));
+	assign(applied, "service", readString(logs, "service"));
+	assign(applied, "env", readString(logs, "env"));
+	assign(applied, "version", 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 = 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 refreshSdkConfig(initConfiguration);
+}
+//#endregion
+export { applyCachedLogsSdkConfiguration, applyLogsSdkConfiguration, scheduleLogsSdkConfigurationRefresh };
+
+//# sourceMappingURL=remoteSdkConfiguration.mjs.map

package/esm/domain/remoteSdkConfiguration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteSdkConfiguration.mjs","names":[],"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,eAAe,mBAAmB,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,IAAI,YAAY,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,qBAAqB,eAAe,MAAM,mBAAmB,CAAC;CAC9E,OAAO,SAAS,uBAAuB,eAAe,MAAM,qBAAqB,CAAC;CAClF,OAAO,SAAS,uBAAuB,YAAY,MAAM,qBAAqB,CAAC;CAC/E,OAAO,SAAS,sBAAsB,YAAY,MAAM,oBAAoB,CAAC;CAC7E,OAAO,SAAS,gCAAgC,YAAY,MAAM,8BAA8B,CAAC;CACjG,OAAO,SAAS,0BAA0B,eAAe,KAAK,sBAAsB,CAAC;CACrF,OAAO,SAAS,sBAAsB,gBAAgB,KAAK,oBAAoB,aAAa,cAAc,CAAC,CAAC;CAC5G,OAAO,SAAS,kBAAkB,gBAAgB,KAAK,gBAAgB,aAAa,aAAa,CAAC,CAAC;CAEnG,OAAO,SAAS,WAAW,WAAW,MAAM,SAAS,CAAC;CACtD,OAAO,SAAS,OAAO,WAAW,MAAM,KAAK,CAAC;CAC9C,OAAO,SAAS,WAAW,WAAW,MAAM,SAAS,CAAC;CAEtD,OAAO;EAAE,mBAAmB;EAAS,aAAa;CAAK;AACzD;;;;;;AAOA,SAAS,gBAAkC,OAAgB,eAAsD;CAC/G,IAAI,UAAU,OACZ,OAAO;CAET,MAAM,QAAQ,eAAe,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,OAAO,iBAAiB,iBAAiB;AAC3C"}

package/esm/domain/report/reportCollection.mjs

@@ -0,0 +1,30 @@
+import { StatusType } from "../logger/isAuthorized.mjs";
+import { createErrorFieldFromRawError } from "../createErrorFieldFromRawError.mjs";
+import "../lifeCycle.mjs";
+import { ErrorSource, getFileFromStackTraceString, initReportObservable } from "@kubesense/kubesense-browser-core";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/report/reportCollection.ts
+function startReportCollection(configuration, lifeCycle) {
+	const reportSubscription = initReportObservable(configuration.forwardReports).subscribe((rawError) => {
+		let message = rawError.message;
+		let error;
+		const status = rawError.originalError.type === "deprecation" ? StatusType.warn : StatusType.error;
+		if (status === StatusType.error) error = createErrorFieldFromRawError(rawError);
+		else if (rawError.stack) message += ` Found in ${getFileFromStackTraceString(rawError.stack)}`;
+		lifeCycle.notify(0, { rawLogsEvent: {
+			date: timeStampNow(),
+			message,
+			origin: ErrorSource.REPORT,
+			error,
+			_kubesense: { debug_ids: rawError.debugIds },
+			status
+		} });
+	});
+	return { stop: () => {
+		reportSubscription.unsubscribe();
+	} };
+}
+//#endregion
+export { startReportCollection };
+
+//# sourceMappingURL=reportCollection.mjs.map

package/esm/domain/report/reportCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportCollection.mjs","names":[],"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,qBAAqB,qBAAqB,cAAc,cAAc,CAAC,CAAC,WAAW,aAAa;EACpG,IAAI,UAAU,SAAS;EACvB,IAAI;EACJ,MAAM,SAAS,SAAS,cAAc,SAAS,gBAAgB,WAAW,OAAO,WAAW;EAE5F,IAAI,WAAW,WAAW,OACxB,QAAQ,6BAA6B,QAAQ;OACxC,IAAI,SAAS,OAClB,WAAW,aAAa,4BAA4B,SAAS,KAAK;EAGpE,UAAU,OAAA,GAA6C,EACrD,cAAc;GACZ,MAAM,aAAa;GACnB;GACA,QAAQ,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/esm/domain/reportError.mjs

@@ -0,0 +1,20 @@
+import { StatusType } from "./logger/isAuthorized.mjs";
+import "./lifeCycle.mjs";
+import { ErrorSource, addTelemetryDebug } from "@kubesense/kubesense-browser-core";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/reportError.ts
+function startReportError(lifeCycle) {
+	return (message) => {
+		lifeCycle.notify(0, { rawLogsEvent: {
+			message,
+			date: timeStampNow(),
+			origin: ErrorSource.AGENT,
+			status: StatusType.error
+		} });
+		addTelemetryDebug("Error reported to customer", { "error.message": message });
+	};
+}
+//#endregion
+export { startReportError };
+
+//# sourceMappingURL=reportError.mjs.map

package/esm/domain/reportError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportError.mjs","names":[],"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,MAAM,aAAa;GACnB,QAAQ,YAAY;GACpB,QAAQ,WAAW;EACrB,EACF,CAAC;EAED,kBAAkB,8BAA8B,EAAE,iBAAiB,QAAQ,CAAC;CAC9E;AACF"}

package/esm/domain/runtimeError/runtimeErrorCollection.mjs

@@ -0,0 +1,29 @@
+import { StatusType } from "../logger/isAuthorized.mjs";
+import { createErrorFieldFromRawError } from "../createErrorFieldFromRawError.mjs";
+import "../lifeCycle.mjs";
+import { combine } from "@kubesense/kubesense-js-core/util";
+import { BufferedDataType, ErrorSource, noop } from "@kubesense/kubesense-browser-core";
+//#region src/domain/runtimeError/runtimeErrorCollection.ts
+function startRuntimeErrorCollection(configuration, lifeCycle, bufferedDataObservable) {
+	if (!configuration.forwardErrorsToLogs) return { stop: noop };
+	const rawErrorSubscription = bufferedDataObservable.subscribe((bufferedData) => {
+		if (bufferedData.type === BufferedDataType.RUNTIME_ERROR) {
+			const error = bufferedData.data;
+			lifeCycle.notify(0, { rawLogsEvent: combine({
+				message: error.message,
+				date: error.startClocks.timeStamp,
+				error: createErrorFieldFromRawError(error),
+				_kubesense: { debug_ids: error.debugIds },
+				origin: ErrorSource.SOURCE,
+				status: StatusType.error
+			}, error.context) });
+		}
+	});
+	return { stop: () => {
+		rawErrorSubscription.unsubscribe();
+	} };
+}
+//#endregion
+export { startRuntimeErrorCollection };
+
+//# sourceMappingURL=runtimeErrorCollection.mjs.map

package/esm/domain/runtimeError/runtimeErrorCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeErrorCollection.mjs","names":[],"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,MAAM,KAAK;CAGtB,MAAM,uBAAuB,uBAAuB,WAAW,iBAAiB;EAC9E,IAAI,aAAa,SAAS,iBAAiB,eAAe;GACxD,MAAM,QAAQ,aAAa;GAC3B,UAAU,OAAA,GAA6C,EACrD,cAAc,QACZ;IACE,SAAS,MAAM;IACf,MAAM,MAAM,YAAY;IACxB,OAAO,6BAA6B,KAAK;IACzC,YAAY,EAAE,WAAW,MAAM,SAAS;IACxC,QAAQ,YAAY;IACpB,QAAQ,WAAW;GACrB,GACA,MAAM,OACR,EACF,CAAC;EACH;CACF,CAAC;CAED,OAAO,EACL,YAAY;EACV,qBAAqB,YAAY;CACnC,EACF;AACF"}

package/esm/entries/main.mjs

@@ -0,0 +1,27 @@
+import { StatusType } from "../domain/logger/isAuthorized.mjs";
+import { HandlerType, Logger } from "../domain/logger.mjs";
+import { makeLogsPublicApi } from "../boot/logsPublicApi.mjs";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+import { defineGlobal } from "@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 = makeLogsPublicApi({ sdkName: "logs" });
+defineGlobal(globalObject, "KUBESENSE_LOGS", kubesenseLogs);
+//#endregion
+export { HandlerType, Logger, StatusType, kubesenseLogs };
+
+//# sourceMappingURL=main.mjs.map

package/esm/entries/main.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.mjs","names":[],"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,gBAAgB,kBAAkB,EAAE,SAAS,OAAO,CAAC;AAKlE,aAAa,cAA+B,kBAAkB,aAAa"}

package/esm/transport/startLogsBatch.mjs

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