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

package/cjs/domain/createErrorFieldFromRawError.js

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

package/cjs/domain/createErrorFieldFromRawError.js.map

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

@@ -0,0 +1,28 @@
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time';
+import type { TelemetryEvent } from '@kubesense/kubesense-browser-core';
+import type { Hook } from '@kubesense/kubesense-js-core/assembly';
+import type { RecursivePartial } from '@kubesense/kubesense-js-core/util';
+import type { LogsEvent } from '../logsEvent.types';
+import type { RawLogsEvent } from '../rawLogsEvent.types';
+import type { LogsEventDomainContext } from '../domainContext.types';
+export type DefaultLogsEventAttributes = RecursivePartial<LogsEvent>;
+export type DefaultTelemetryEventAttributes = RecursivePartial<TelemetryEvent>;
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+export interface AssembleHookParams {
+    readonly startTime: RelativeTime;
+    rawLogsEvent: DeepReadonly<RawLogsEvent>;
+    domainContext: DeepReadonly<LogsEventDomainContext>;
+}
+export type AssembleHook = Hook<AssembleHookParams, DefaultLogsEventAttributes>;
+export type AssembleTelemetryHook = Hook<{
+    startTime: RelativeTime;
+}, DefaultTelemetryEventAttributes>;
+export interface Hooks {
+    assembleEventDefaults: AssembleHook;
+    assembleTelemetry: AssembleTelemetryHook;
+    assembleEvent: AssembleHook;
+}
+export declare function createHooks(): Hooks;
+export {};

package/cjs/domain/hooks.js

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

package/cjs/domain/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":["createHook"],"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,wBAAA,GAAuBA,sCAAAA,WAAAA,CAAW;EAClC,oBAAA,GAAmBA,sCAAAA,WAAAA,CAAW;EAC9B,gBAAA,GAAeA,sCAAAA,WAAAA,CAAW;CAC5B;AACF"}

package/cjs/domain/lifeCycle.d.ts

@@ -0,0 +1,24 @@
+import { AbstractLifeCycle } from '@kubesense/kubesense-browser-core';
+import type { Context } from '@kubesense/kubesense-browser-core';
+import type { LogsEvent } from '../logsEvent.types';
+import type { CommonContext, RawLogsEvent } from '../rawLogsEvent.types';
+import type { LogsEventDomainContext } from '../domainContext.types';
+export declare const enum LifeCycleEventType {
+    RAW_LOG_COLLECTED = 0,
+    LOG_COLLECTED = 1
+}
+interface LifeCycleEventMap {
+    [LifeCycleEventType.RAW_LOG_COLLECTED]: RawLogsEventCollectedData;
+    [LifeCycleEventType.LOG_COLLECTED]: LogsEvent & Context;
+}
+export declare const LifeCycle: {
+    new (): AbstractLifeCycle<LifeCycleEventMap>;
+};
+export type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>;
+export interface RawLogsEventCollectedData<E extends RawLogsEvent = RawLogsEvent> {
+    rawLogsEvent: E;
+    savedCommonContext?: CommonContext;
+    domainContext?: LogsEventDomainContext<E['origin']>;
+    ktags?: string[];
+}
+export {};

package/cjs/domain/lifeCycle.js

@@ -0,0 +1,6 @@
+//#region src/domain/lifeCycle.ts
+const LifeCycle = require("@kubesense/kubesense-browser-core").AbstractLifeCycle;
+//#endregion
+exports.LifeCycle = LifeCycle;
+
+//# sourceMappingURL=lifeCycle.js.map

package/cjs/domain/lifeCycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeCycle.js","names":["AbstractLifeCycle"],"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,uDAAYA,CAAAA,CAAAA"}

package/cjs/domain/logger/isAuthorized.d.ts

@@ -0,0 +1,17 @@
+import type { Logger, HandlerType } from '../logger';
+export declare function isAuthorized(status: StatusType, handlerType: HandlerType, logger: Logger): boolean;
+export declare const StatusType: {
+    readonly ok: "ok";
+    readonly debug: "debug";
+    readonly info: "info";
+    readonly notice: "notice";
+    readonly warn: "warn";
+    readonly error: "error";
+    readonly critical: "critical";
+    readonly alert: "alert";
+    readonly emerg: "emerg";
+};
+export declare const STATUS_PRIORITIES: {
+    [key in StatusType]: number;
+};
+export type StatusType = (typeof StatusType)[keyof typeof StatusType];

package/cjs/domain/logger/isAuthorized.js

@@ -0,0 +1,34 @@
+//#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
+exports.STATUS_PRIORITIES = STATUS_PRIORITIES;
+exports.StatusType = StatusType;
+exports.isAuthorized = isAuthorized;
+
+//# sourceMappingURL=isAuthorized.js.map

package/cjs/domain/logger/isAuthorized.js.map

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

@@ -0,0 +1,7 @@
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time';
+import type { CommonContext } from '../../rawLogsEvent.types';
+import type { LifeCycle } from '../lifeCycle';
+import type { Logger, LogsMessage } from '../logger';
+export declare function startLoggerCollection(lifeCycle: LifeCycle): {
+    handleLog: (logsMessage: LogsMessage, logger: Logger, handlingStack?: string, savedCommonContext?: CommonContext, savedDate?: TimeStamp) => void;
+};

package/cjs/domain/logger/loggerCollection.js

@@ -0,0 +1,47 @@
+const require_isAuthorized = require("./isAuthorized.js");
+const require_logger = require("../logger.js");
+require("../lifeCycle.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/logger/loggerCollection.ts
+function startLoggerCollection(lifeCycle) {
+	function handleLog(logsMessage, logger, handlingStack, savedCommonContext, savedDate) {
+		const messageContext = (0, _kubesense_kubesense_js_core_util.combine)(logger.getContext(), logsMessage.context);
+		if (require_isAuthorized.isAuthorized(logsMessage.status, require_logger.HandlerType.console, logger)) displayInConsole(logsMessage, messageContext);
+		if (require_isAuthorized.isAuthorized(logsMessage.status, require_logger.HandlerType.http, logger)) {
+			const rawLogEventData = {
+				rawLogsEvent: (0, _kubesense_kubesense_js_core_util.combine)({
+					date: savedDate || (0, _kubesense_kubesense_js_core_time.timeStampNow)(),
+					message: logsMessage.message,
+					status: logsMessage.status,
+					origin: _kubesense_kubesense_browser_core.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 = {
+	[require_isAuthorized.StatusType.ok]: _kubesense_kubesense_js_core_util.ConsoleApiName.debug,
+	[require_isAuthorized.StatusType.debug]: _kubesense_kubesense_js_core_util.ConsoleApiName.debug,
+	[require_isAuthorized.StatusType.info]: _kubesense_kubesense_js_core_util.ConsoleApiName.info,
+	[require_isAuthorized.StatusType.notice]: _kubesense_kubesense_js_core_util.ConsoleApiName.info,
+	[require_isAuthorized.StatusType.warn]: _kubesense_kubesense_js_core_util.ConsoleApiName.warn,
+	[require_isAuthorized.StatusType.error]: _kubesense_kubesense_js_core_util.ConsoleApiName.error,
+	[require_isAuthorized.StatusType.critical]: _kubesense_kubesense_js_core_util.ConsoleApiName.error,
+	[require_isAuthorized.StatusType.alert]: _kubesense_kubesense_js_core_util.ConsoleApiName.error,
+	[require_isAuthorized.StatusType.emerg]: _kubesense_kubesense_js_core_util.ConsoleApiName.error
+};
+function displayInConsole({ status, message }, messageContext) {
+	_kubesense_kubesense_js_core_util.originalConsoleMethods[loggerToConsoleApiName[status]].call(_kubesense_kubesense_js_core_util.globalConsole, message, messageContext);
+}
+//#endregion
+exports.startLoggerCollection = startLoggerCollection;
+
+//# sourceMappingURL=loggerCollection.js.map

package/cjs/domain/logger/loggerCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loggerCollection.js","names":["combine","isAuthorized","HandlerType","timeStampNow","ErrorSource","StatusType","ConsoleApiName","globalConsole"],"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,kBAAA,GAAiBA,kCAAAA,QAAAA,CAAQ,OAAO,WAAW,GAAG,YAAY,OAAO;EAEvE,IAAIC,qBAAAA,aAAa,YAAY,QAAQC,eAAAA,YAAY,SAAS,MAAM,GAC9D,iBAAiB,aAAa,cAAc;EAG9C,IAAID,qBAAAA,aAAa,YAAY,QAAQC,eAAAA,YAAY,MAAM,MAAM,GAAG;GAC9D,MAAM,kBAA2D;IAC/D,eAAA,GAAcF,kCAAAA,QAAAA,CACZ;KACE,MAAM,cAAA,GAAaG,kCAAAA,aAAAA,CAAa;KAChC,SAAS,YAAY;KACrB,QAAQ,YAAY;KACpB,QAAQC,kCAAAA,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;EACrEC,qBAAAA,WAAW,KAAKC,kCAAAA,eAAe;EAC/BD,qBAAAA,WAAW,QAAQC,kCAAAA,eAAe;EAClCD,qBAAAA,WAAW,OAAOC,kCAAAA,eAAe;EACjCD,qBAAAA,WAAW,SAASC,kCAAAA,eAAe;EACnCD,qBAAAA,WAAW,OAAOC,kCAAAA,eAAe;EACjCD,qBAAAA,WAAW,QAAQC,kCAAAA,eAAe;EAClCD,qBAAAA,WAAW,WAAWC,kCAAAA,eAAe;EACrCD,qBAAAA,WAAW,QAAQC,kCAAAA,eAAe;EAClCD,qBAAAA,WAAW,QAAQC,kCAAAA,eAAe;AACrC;AAEA,SAAS,iBAAiB,EAAE,QAAQ,WAAwB,gBAAqC;CAC/F,kCAAA,uBAAuB,uBAAuB,QAAQ,CAAC,KAAKC,kCAAAA,eAAe,SAAS,cAAc;AACpG"}

package/cjs/domain/logger.d.ts

@@ -0,0 +1,48 @@
+import type { Context, DebugIdEntry } from '@kubesense/kubesense-browser-core';
+import { StatusType } from './logger/isAuthorized';
+export interface LogsMessage {
+    message: string;
+    status: StatusType;
+    context?: Context;
+    debugIds?: DebugIdEntry[];
+}
+export declare const HandlerType: {
+    readonly console: "console";
+    readonly http: "http";
+    readonly silent: "silent";
+};
+export type HandlerType = (typeof HandlerType)[keyof typeof HandlerType];
+export declare const STATUSES: StatusType[];
+export declare class Logger {
+    private handleLogStrategy;
+    private handlerType;
+    private level;
+    private contextManager;
+    private tags;
+    constructor(handleLogStrategy: (logsMessage: LogsMessage, logger: Logger, handlingStack?: string) => void, name?: string, handlerType?: HandlerType | HandlerType[], level?: StatusType, loggerContext?: object);
+    logImplementation(message: string, messageContext?: object, status?: StatusType, error?: Error, handlingStack?: string): void;
+    log(message: string, messageContext?: object, status?: StatusType, error?: Error): void;
+    setContext(context: object): void;
+    getContext(): Context;
+    setContextProperty(key: string, value: any): void;
+    removeContextProperty(key: string): void;
+    clearContext(): void;
+    addTag(key: string, value?: string): void;
+    removeTagsWithKey(key: string): void;
+    getTags(): string[];
+    setHandler(handler: HandlerType | HandlerType[]): void;
+    getHandler(): HandlerType | HandlerType[];
+    setLevel(level: StatusType): void;
+    getLevel(): StatusType;
+}
+export interface Logger {
+    ok(message: string, messageContext?: object, error?: Error): void;
+    debug(message: string, messageContext?: object, error?: Error): void;
+    info(message: string, messageContext?: object, error?: Error): void;
+    notice(message: string, messageContext?: object, error?: Error): void;
+    warn(message: string, messageContext?: object, error?: Error): void;
+    error(message: string, messageContext?: object, error?: Error): void;
+    critical(message: string, messageContext?: object, error?: Error): void;
+    alert(message: string, messageContext?: object, error?: Error): void;
+    emerg(message: string, messageContext?: object, error?: Error): void;
+}

package/cjs/domain/logger.js

@@ -0,0 +1,112 @@
+const require_isAuthorized = require("./logger/isAuthorized.js");
+const require_createErrorFieldFromRawError = require("./createErrorFieldFromRawError.js");
+let _kubesense_kubesense_js_core_util = require("@kubesense/kubesense-js-core/util");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_monitor = require("@kubesense/kubesense-js-core/monitor");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/logger.ts
+const HandlerType = {
+	console: "console",
+	http: "http",
+	silent: "silent"
+};
+const STATUSES = Object.keys(require_isAuthorized.StatusType);
+var Logger = class {
+	constructor(handleLogStrategy, name, handlerType = HandlerType.http, level = require_isAuthorized.StatusType.debug, loggerContext = {}) {
+		this.handleLogStrategy = handleLogStrategy;
+		this.handlerType = handlerType;
+		this.level = level;
+		this.contextManager = (0, _kubesense_kubesense_browser_core.createContextManager)("logger");
+		this.tags = [];
+		this.contextManager.setContext(loggerContext);
+		if (name) this.contextManager.setContextProperty("logger", { name });
+	}
+	logImplementation(message, messageContext, status = require_isAuthorized.StatusType.info, error, handlingStack) {
+		(0, _kubesense_kubesense_js_core_monitor.callMonitored)(() => {
+			const sanitizedMessageContext = (0, _kubesense_kubesense_browser_core.sanitize)(messageContext);
+			let context;
+			let debugIds;
+			if (error !== void 0 && error !== null) {
+				const rawError = (0, _kubesense_kubesense_browser_core.computeRawError)({
+					originalError: error,
+					nonErrorPrefix: _kubesense_kubesense_browser_core.NonErrorPrefix.PROVIDED,
+					source: _kubesense_kubesense_browser_core.ErrorSource.LOGGER,
+					handling: _kubesense_kubesense_browser_core.ErrorHandling.HANDLED,
+					startClocks: (0, _kubesense_kubesense_js_core_time.clocksNow)()
+				});
+				debugIds = rawError.debugIds;
+				context = (0, _kubesense_kubesense_js_core_util.combine)({ error: require_createErrorFieldFromRawError.createErrorFieldFromRawError(rawError, { includeMessage: true }) }, rawError.context, sanitizedMessageContext);
+			} else context = sanitizedMessageContext;
+			this.handleLogStrategy({
+				message: (0, _kubesense_kubesense_browser_core.sanitize)(message),
+				context,
+				status,
+				...debugIds ? { debugIds } : {}
+			}, this, handlingStack);
+		});
+	}
+	log(message, messageContext, status = require_isAuthorized.StatusType.info, error) {
+		let handlingStack;
+		if (require_isAuthorized.isAuthorized(status, HandlerType.http, this)) handlingStack = (0, _kubesense_kubesense_browser_core.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((0, _kubesense_kubesense_browser_core.buildTag)(key, value));
+	}
+	removeTagsWithKey(key) {
+		const sanitizedKey = (0, _kubesense_kubesense_browser_core.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(require_isAuthorized.StatusType.ok);
+Logger.prototype.debug = createLoggerMethod(require_isAuthorized.StatusType.debug);
+Logger.prototype.info = createLoggerMethod(require_isAuthorized.StatusType.info);
+Logger.prototype.notice = createLoggerMethod(require_isAuthorized.StatusType.notice);
+Logger.prototype.warn = createLoggerMethod(require_isAuthorized.StatusType.warn);
+Logger.prototype.error = createLoggerMethod(require_isAuthorized.StatusType.error);
+Logger.prototype.critical = createLoggerMethod(require_isAuthorized.StatusType.critical);
+Logger.prototype.alert = createLoggerMethod(require_isAuthorized.StatusType.alert);
+Logger.prototype.emerg = createLoggerMethod(require_isAuthorized.StatusType.emerg);
+function createLoggerMethod(status) {
+	return function(message, messageContext, error) {
+		let handlingStack;
+		if (require_isAuthorized.isAuthorized(status, HandlerType.http, this)) handlingStack = (0, _kubesense_kubesense_browser_core.createHandlingStack)("log");
+		this.logImplementation(message, messageContext, status, error, handlingStack);
+	};
+}
+//#endregion
+exports.HandlerType = HandlerType;
+exports.Logger = Logger;
+exports.STATUSES = STATUSES;
+
+//# sourceMappingURL=logger.js.map

package/cjs/domain/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":["StatusType","createContextManager","sanitize","computeRawError","NonErrorPrefix","ErrorSource","ErrorHandling","clocksNow","combine","createErrorFieldFromRawError","isAuthorized","createHandlingStack","buildTag","sanitizeTag"],"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":"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"}

package/cjs/domain/networkError/networkErrorCollection.d.ts

@@ -0,0 +1,9 @@
+import type { Observable, BufferedData } from '@kubesense/kubesense-browser-core';
+import { noop } from '@kubesense/kubesense-browser-core';
+import type { LogsConfiguration } from '../configuration';
+/** arbitrary value, byte precision not needed */
+export declare const DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT: number;
+import type { LifeCycle } from '../lifeCycle';
+export declare function startNetworkErrorCollection(configuration: LogsConfiguration, lifeCycle: LifeCycle, bufferedDataObservable: Observable<BufferedData>): {
+    stop: typeof noop;
+};

package/cjs/domain/networkError/networkErrorCollection.js

@@ -0,0 +1,57 @@
+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_transport = require("@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 * _kubesense_kubesense_browser_core.ONE_KIBI_BYTE;
+function startNetworkErrorCollection(configuration, lifeCycle, bufferedDataObservable) {
+	if (!configuration.forwardErrorsToLogs) return { stop: _kubesense_kubesense_browser_core.noop };
+	(0, _kubesense_kubesense_browser_core.initFetchObservable)({ responseBodyAction: (context) => isNetworkError(context) ? _kubesense_kubesense_browser_core.ResponseBodyAction.COLLECT : _kubesense_kubesense_browser_core.ResponseBodyAction.IGNORE });
+	const subscription = bufferedDataObservable.subscribe(({ data, type }) => {
+		if (type === _kubesense_kubesense_browser_core.BufferedDataType.FETCH && data.state === "resolve") handleResponse(_kubesense_kubesense_browser_core.RequestType.FETCH, data);
+		else if (type === _kubesense_kubesense_browser_core.BufferedDataType.XHR && data.state === "complete") handleResponse(_kubesense_kubesense_browser_core.RequestType.XHR, data);
+	});
+	function isNetworkError(request) {
+		return !(0, _kubesense_kubesense_js_core_transport.isIntakeUrl)(request.url) && !request.isAborted && (isRejected(request) || (0, _kubesense_kubesense_browser_core.isServerError)(request.status));
+	}
+	function handleResponse(type, request) {
+		if (!isNetworkError(request)) return;
+		const stackTrace = "error" in request && request.error ? (0, _kubesense_kubesense_browser_core.computeStackTrace)(request.error) : void 0;
+		const stack = stackTrace ? (0, _kubesense_kubesense_browser_core.toStackTraceString)(stackTrace) : request.responseBody || "Failed to load";
+		const debugIds = stackTrace ? (0, _kubesense_kubesense_browser_core.buildDebugIdByUrl)((0, _kubesense_kubesense_browser_core.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: (0, _kubesense_kubesense_browser_core.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: require_isAuthorized.StatusType.error,
+				origin: _kubesense_kubesense_browser_core.ErrorSource.NETWORK
+			},
+			domainContext
+		});
+	}
+	return { stop: () => subscription.unsubscribe() };
+}
+function isRejected(request) {
+	return request.status === 0 && request.responseType !== "opaque";
+}
+function format(type) {
+	if (_kubesense_kubesense_browser_core.RequestType.XHR === type) return "XHR";
+	return "Fetch";
+}
+//#endregion
+exports.DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT;
+exports.startNetworkErrorCollection = startNetworkErrorCollection;
+
+//# sourceMappingURL=networkErrorCollection.js.map

package/cjs/domain/networkError/networkErrorCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkErrorCollection.js","names":["ONE_KIBI_BYTE","noop","ResponseBodyAction","BufferedDataType","RequestType","isIntakeUrl","isServerError","computeStackTrace","toStackTraceString","buildDebugIdByUrl","getStackTraceUrls","safeTruncate","StatusType","ErrorSource"],"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,KAAKA,kCAAAA;AAMhE,SAAgB,4BACd,eACA,WACA,wBACA;CACA,IAAI,CAAC,cAAc,qBACjB,OAAO,EAAE,MAAMC,kCAAAA,KAAK;CAItB,CAAA,GAAA,kCAAA,oBAAA,CAAoB,EAClB,qBAAqB,YAAa,eAAe,OAAO,IAAIC,kCAAAA,mBAAmB,UAAUA,kCAAAA,mBAAmB,OAC9G,CAAC;CAED,MAAM,eAAe,uBAAuB,WAAW,EAAE,MAAM,WAAW;EACxE,IAAI,SAASC,kCAAAA,iBAAiB,SAAS,KAAK,UAAU,WACpD,eAAeC,kCAAAA,YAAY,OAAO,IAAI;OACjC,IAAI,SAASD,kCAAAA,iBAAiB,OAAO,KAAK,UAAU,YACzD,eAAeC,kCAAAA,YAAY,KAAK,IAAI;CAExC,CAAC;CAED,SAAS,eAAe,SAAmD;EACzE,OAAO,EAAA,GAACC,uCAAAA,YAAAA,CAAY,QAAQ,GAAG,KAAK,CAAC,QAAQ,cAAc,WAAW,OAAO,MAAA,GAAKC,kCAAAA,cAAAA,CAAc,QAAQ,MAAM;CAChH;CAEA,SAAS,eAAe,MAAmB,SAAmD;EAC5F,IAAI,CAAC,eAAe,OAAO,GACzB;EAEF,MAAM,aAAa,WAAW,WAAW,QAAQ,SAAA,GAAQC,kCAAAA,kBAAAA,CAAkB,QAAQ,KAAK,IAAI,KAAA;EAC5F,MAAM,QAAQ,cAAA,GAAaC,kCAAAA,mBAAAA,CAAmB,UAAU,IAAI,QAAQ,gBAAgB;EACpF,MAAM,WAAW,cAAA,GAAaC,kCAAAA,kBAAAA,EAAAA,GAAkBC,kCAAAA,kBAAAA,CAAkB,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,QAAA,GAAOC,kCAAAA,aAAAA,CAAa,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,QAAQC,qBAAAA,WAAW;IACnB,QAAQC,kCAAAA,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,IAAIT,kCAAAA,YAAY,QAAQ,MACtB,OAAO;CAET,OAAO;AACT"}

package/cjs/domain/plugins.d.ts

@@ -0,0 +1,49 @@
+import type { LogsPublicApi } from '../boot/logsPublicApi';
+import type { StartLogsResult } from '../boot/startLogs';
+import type { LogsInitConfiguration } from './configuration';
+import type { AssembleHook } from './hooks';
+/**
+ * onInit plugin API options.
+ *
+ * @experimental
+ */
+export interface OnInitOptions {
+    initConfiguration: LogsInitConfiguration;
+    publicApi: LogsPublicApi;
+    /**
+     * Register a callback invoked when a log event is assembled, so plugins can enrich or override
+     * log fields before they are sent. Callbacks registered in `onInit` run before any log is
+     * assembled, including logs buffered during the pre-start phase.
+     */
+    registerAssembleEventHook: AssembleHook['register'];
+}
+/**
+ * onLogsStart plugin API options.
+ *
+ * @experimental
+ */
+export interface OnLogsStartOptions {
+    /**
+     * Emit a log with the same pipeline as a logger call.
+     */
+    handleLog: StartLogsResult['handleLog'];
+}
+/**
+ * Plugin interface of the Logs browser SDK.
+ *
+ * The plugins API is unstable and experimental, and may change without
+ * notice. Please use only plugins provided by KubeSense matching the version of the SDK you are
+ * using.
+ *
+ * @experimental
+ */
+export interface LogsPlugin {
+    name: string;
+    getConfigurationTelemetry?(): Record<string, unknown>;
+    onInit?(options: OnInitOptions): void;
+    onLogsStart?(options: OnLogsStartOptions): void;
+}
+type MethodNames = 'onInit' | 'onLogsStart';
+type MethodParameter<MethodName extends MethodNames> = Parameters<NonNullable<LogsPlugin[MethodName]>>[0];
+export declare function callPluginsMethod<MethodName extends MethodNames>(plugins: LogsPlugin[] | undefined, methodName: MethodName, parameter: MethodParameter<MethodName>): void;
+export {};

package/cjs/domain/plugins.js

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

package/cjs/domain/plugins.js.map

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

@@ -0,0 +1,26 @@
+import type { RemoteSdkConfig } from '@kubesense/kubesense-browser-core';
+import type { LogsInitConfiguration } from './configuration';
+/**
+ * Applies the dashboard-managed configuration document to the Logs init configuration.
+ *
+ * The Logs SDK reads the same cached document as RUM (they share one local-storage entry), but
+ * only consumes the `features.logs` switch and the `logs` section — RUM settings never leak
+ * into Logs, and vice versa.
+ *
+ * As in RUM, a missing or invalid field leaves the local `init()` value untouched, and
+ * identity/endpoint settings are never remotable.
+ */
+export interface LogsRemoteSdkConfigurationResult {
+    initConfiguration: LogsInitConfiguration;
+    /** `false` when the dashboard has switched Logs off entirely. */
+    logsEnabled: boolean;
+}
+export declare function applyCachedLogsSdkConfiguration(initConfiguration: LogsInitConfiguration): LogsRemoteSdkConfigurationResult;
+export declare function applyLogsSdkConfiguration(initConfiguration: LogsInitConfiguration, remoteConfig: RemoteSdkConfig): LogsRemoteSdkConfigurationResult;
+/**
+ * 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.
+ */
+export declare function scheduleLogsSdkConfigurationRefresh(initConfiguration: LogsInitConfiguration): Promise<void>;