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

package/src/boot/startLogs.ts

@@ -0,0 +1,83 @@
+import type { BufferedObservable, BufferedData, SessionManager } from '@kubesense/kubesense-browser-core'
+import {
+  sendToExtension,
+  canUseEventBridge,
+  startAccountContext,
+  startGlobalContext,
+  startUserContext,
+  startTabContext,
+} from '@kubesense/kubesense-browser-core'
+import type { LogsConfiguration } from '../domain/configuration'
+import { startLogsAssembly } from '../domain/assembly'
+import { startConsoleCollection } from '../domain/console/consoleCollection'
+import { startReportCollection } from '../domain/report/reportCollection'
+import { startNetworkErrorCollection } from '../domain/networkError/networkErrorCollection'
+import { startRuntimeErrorCollection } from '../domain/runtimeError/runtimeErrorCollection'
+import { LifeCycle, LifeCycleEventType } from '../domain/lifeCycle'
+import { startLoggerCollection } from '../domain/logger/loggerCollection'
+import { startLogsBatch } from '../transport/startLogsBatch'
+import { startLogsBridge } from '../transport/startLogsBridge'
+import { startInternalContext } from '../domain/contexts/internalContext'
+import { startReportError } from '../domain/reportError'
+import type { CommonContext } from '../rawLogsEvent.types'
+import type { Hooks } from '../domain/hooks'
+import { startRUMInternalContext } from '../domain/contexts/rumInternalContext'
+import { startSessionContext } from '../domain/contexts/sessionContext'
+
+const LOGS_STORAGE_KEY = 'logs'
+
+export type StartLogs = typeof startLogs
+export type StartLogsResult = ReturnType<StartLogs>
+
+export function startLogs(
+  configuration: LogsConfiguration,
+  sessionManager: SessionManager,
+  getCommonContext: () => CommonContext,
+  bufferedDataObservable: BufferedObservable<BufferedData>,
+  hooks: Hooks
+) {
+  const lifeCycle = new LifeCycle()
+  const cleanupTasks: Array<() => void> = []
+
+  lifeCycle.subscribe(LifeCycleEventType.LOG_COLLECTED, (log) => sendToExtension('logs', log))
+
+  const reportError = startReportError(lifeCycle)
+
+  // Start user and account context first to allow overrides from global context
+  const { assembleEventDefaults: assembleHook } = hooks
+  startSessionContext(assembleHook, configuration, sessionManager)
+  const accountContext = startAccountContext(assembleHook, configuration, LOGS_STORAGE_KEY)
+  const userContext = startUserContext(assembleHook, configuration, sessionManager, LOGS_STORAGE_KEY)
+  const globalContext = startGlobalContext(assembleHook, configuration, LOGS_STORAGE_KEY, false)
+  startRUMInternalContext(hooks)
+  startTabContext(assembleHook)
+
+  startNetworkErrorCollection(configuration, lifeCycle, bufferedDataObservable)
+  startRuntimeErrorCollection(configuration, lifeCycle, bufferedDataObservable)
+  startConsoleCollection(configuration, lifeCycle, bufferedDataObservable)
+  bufferedDataObservable.unbuffer()
+  startReportCollection(configuration, lifeCycle)
+  const { handleLog } = startLoggerCollection(lifeCycle)
+
+  startLogsAssembly(configuration, lifeCycle, hooks, getCommonContext, reportError)
+
+  if (!canUseEventBridge()) {
+    const { stop: stopLogsBatch } = startLogsBatch(configuration, lifeCycle, reportError, sessionManager)
+    cleanupTasks.push(() => stopLogsBatch())
+  } else {
+    startLogsBridge(lifeCycle)
+  }
+
+  const internalContext = startInternalContext(sessionManager)
+
+  return {
+    handleLog,
+    getInternalContext: internalContext.get,
+    accountContext,
+    globalContext,
+    userContext,
+    stop: () => {
+      cleanupTasks.forEach((task) => task())
+    },
+  }
+}

package/src/domain/assembly.ts

@@ -0,0 +1,73 @@
+import type { Context, EventRateLimiter } from '@kubesense/kubesense-browser-core'
+import { ErrorSource, buildTags, createEventRateLimiter } from '@kubesense/kubesense-browser-core'
+import { toRelativeTime } from '@kubesense/kubesense-js-core/time'
+import { DISCARDED } from '@kubesense/kubesense-js-core/assembly'
+import { combine } from '@kubesense/kubesense-js-core/util'
+import type { CommonContext } from '../rawLogsEvent.types'
+import type { LogsEvent } from '../logsEvent.types'
+import type { LogsConfiguration } from './configuration'
+import type { LifeCycle } from './lifeCycle'
+import { LifeCycleEventType } from './lifeCycle'
+import { STATUSES } from './logger'
+import type { Hooks, AssembleHookParams } from './hooks'
+
+export function startLogsAssembly(
+  configuration: LogsConfiguration,
+  lifeCycle: LifeCycle,
+  hooks: Hooks,
+  getCommonContext: () => CommonContext,
+  reportError: (message: string) => void,
+  eventRateLimit?: number
+) {
+  const statusWithCustom = (STATUSES as string[]).concat(['custom'])
+  const logRateLimiters: { [key: string]: EventRateLimiter } = {}
+  statusWithCustom.forEach((status) => {
+    logRateLimiters[status] = createEventRateLimiter(status, reportError, eventRateLimit)
+  })
+
+  lifeCycle.subscribe(
+    LifeCycleEventType.RAW_LOG_COLLECTED,
+    ({ rawLogsEvent, savedCommonContext = undefined, domainContext, ktags = [] }) => {
+      const startTime = toRelativeTime(rawLogsEvent.date)
+      const commonContext = savedCommonContext || getCommonContext()
+      const assemblyParams: AssembleHookParams = {
+        startTime,
+        rawLogsEvent: rawLogsEvent as AssembleHookParams['rawLogsEvent'],
+        domainContext,
+      }
+      const defaultLogsEventAttributes = hooks.assembleEventDefaults.trigger(assemblyParams)
+      if (defaultLogsEventAttributes === DISCARDED) {
+        return
+      }
+
+      const logsEventAttributes = hooks.assembleEvent.trigger(assemblyParams)!
+      if (logsEventAttributes === DISCARDED) {
+        return
+      }
+
+      const defaultKtags = buildTags(configuration)
+
+      const log = combine(
+        {
+          view: commonContext.view,
+        },
+        defaultLogsEventAttributes,
+        rawLogsEvent,
+        logsEventAttributes,
+        {
+          ktags: defaultKtags.concat(ktags).join(','),
+        }
+      ) as LogsEvent & Context
+
+      if (
+        configuration.beforeSend?.(log, domainContext) === false ||
+        (log.origin !== ErrorSource.AGENT &&
+          (logRateLimiters[log.status] ?? logRateLimiters['custom']).isLimitReached())
+      ) {
+        return
+      }
+
+      lifeCycle.notify(LifeCycleEventType.LOG_COLLECTED, log)
+    }
+  )
+}

package/src/domain/configuration.ts

@@ -0,0 +1,176 @@
+import type { InitConfiguration, RawTelemetryConfiguration } from '@kubesense/kubesense-browser-core'
+import { ConsoleApiName } from '@kubesense/kubesense-js-core/util'
+import {
+  serializeConfiguration,
+  catchUserErrors,
+  display,
+  RawReportType,
+  BROWSER_CORE_SCHEMA,
+} from '@kubesense/kubesense-browser-core'
+import { validateAndBuildConfiguration } from '@kubesense/kubesense-js-core/configuration'
+import type { InferredConfig } from '@kubesense/kubesense-js-core/configuration'
+import type { LogsEvent } from '../logsEvent.types'
+import type { LogsEventDomainContext } from '../domainContext.types'
+import type { LogsPlugin } from './plugins'
+
+/**
+ * Init Configuration for the Logs browser SDK.
+ *
+ * @category Main
+ * @example NPM
+ * ```ts
+ * import { kubesenseLogs } from '@kubesense/kubesense-browser-logs'
+ *
+ * kubesenseLogs.init({
+ *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',
+ *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',
+ *   // ...
+ * })
+ * ```
+ * @example CDN
+ * ```ts
+ * KUBESENSE_LOGS.init({
+ *   clientToken: '<KUBESENSE_CLIENT_TOKEN>',
+ *   kubesenseRumEndpoint: '<KUBESENSE_RUM_ENDPOINT>',
+ *   // ...
+ * })
+ * ```
+ */
+export interface LogsInitConfiguration extends InitConfiguration {
+  /**
+   * Access to every logs collected by the Logs SDK before they are sent to KubeSense.
+   * It allows:
+   * - Enrich your logs with additional context attributes
+   * - Modify your logs to modify their content, or redact sensitive sequences (see the list of editable properties)
+   * - Discard selected logs
+   *
+   * @category Data Collection
+   */
+  beforeSend?: LogsBeforeSend | undefined
+
+  /**
+   * Forward uncaught exceptions and network errors to KubeSense.
+   *
+   * To capture `console.error` calls, use {@link forwardConsoleLogs} with `"error"` (or `"all"`).
+   *
+   * @category Data Collection
+   * @defaultValue true
+   * @see forwardConsoleLogs
+   */
+  forwardErrorsToLogs?: boolean | undefined
+
+  /**
+   * Forward logs from console.* to KubeSense. Use "all" to forward everything or an array of console API names to forward only a subset.
+   *
+   * @category Data Collection
+   */
+  forwardConsoleLogs?: ConsoleApiName[] | 'all' | undefined
+
+  /**
+   * Forward reports from the [Reporting API](https://developer.mozilla.org/en-US/docs/Web/API/Reporting_API) to KubeSense. Use "all" to forward everything or an array of report types to forward only a subset.
+   *
+   * @category Data Collection
+   */
+  forwardReports?: RawReportType[] | 'all' | undefined
+
+  /**
+   * List of plugins to enable. The plugins API is unstable and experimental, and may change without
+   * notice. Please use only plugins provided by KubeSense matching the version of the SDK you are
+   * using.
+   *
+   * @experimental
+   */
+  plugins?: LogsPlugin[] | undefined
+
+  /**
+   * Enable dashboard-managed SDK settings served by the KubeSense collector.
+   *
+   * Logs reads the same cached document as RUM, but only consumes the `features.logs` switch and
+   * the `logs` section. The document is fetched asynchronously after the SDK starts, so it never
+   * delays initialization, and cached settings are applied on the next page load.
+   *
+   * @category Data Collection
+   * @defaultValue false
+   */
+  enableRemoteSdkConfiguration?: boolean | undefined
+}
+
+/**
+ * Function called before a Log event is sent to KubeSense. See {@link LogsInitConfiguration.beforeSend}
+ *
+ * @param event - The log event
+ * @param context - The log event domain context
+ * @returns true if the event should be sent to KubeSense, false otherwise
+ */
+export type LogsBeforeSend = (event: LogsEvent, context: LogsEventDomainContext) => boolean
+
+export const LOGS_SCHEMA = {
+  ...BROWSER_CORE_SCHEMA,
+  forwardErrorsToLogs: { type: 'boolean', default: true, strict: false },
+  enableRemoteSdkConfiguration: { type: 'boolean', default: false, strict: false },
+  forwardConsoleLogs: {
+    type: 'enum',
+    values: ConsoleApiName,
+    multiple: true,
+    allowAll: true,
+    default: [] as ConsoleApiName[],
+  },
+  forwardReports: {
+    type: 'enum',
+    values: RawReportType,
+    multiple: true,
+    allowAll: true,
+    default: [] as RawReportType[],
+  },
+  plugins: {
+    type: 'schema',
+    multiple: true,
+    strict: false,
+    default: [] as LogsPlugin[],
+    schema: {
+      name: { type: 'string', required: true },
+      getConfigurationTelemetry: {
+        type: 'function',
+        strict: false,
+        signature: undefined as LogsPlugin['getConfigurationTelemetry'],
+      },
+      onInit: { type: 'function', strict: false, signature: undefined as LogsPlugin['onInit'] },
+      onLogsStart: { type: 'function', strict: false, signature: undefined as LogsPlugin['onLogsStart'] },
+    },
+  },
+} as const
+
+export type LogsConfiguration = InferredConfig<typeof LOGS_SCHEMA>
+
+export function validateAndBuildLogsConfiguration(
+  initConfiguration: LogsInitConfiguration
+): LogsConfiguration | undefined {
+  const config = validateAndBuildConfiguration(
+    initConfiguration as unknown as Record<string, unknown>,
+    LOGS_SCHEMA,
+    display
+  )
+  if (!config) {
+    return
+  }
+  return {
+    ...config,
+    beforeSend: config.beforeSend ? catchUserErrors(config.beforeSend as any, 'beforeSend threw an error:') : undefined,
+  }
+}
+
+export function serializeLogsConfiguration(configuration: LogsInitConfiguration) {
+  const baseSerializedInitConfiguration = serializeConfiguration(configuration)
+
+  return {
+    forward_errors_to_logs: configuration.forwardErrorsToLogs,
+    enable_remote_sdk_configuration: !!configuration.enableRemoteSdkConfiguration,
+    forward_console_logs: configuration.forwardConsoleLogs,
+    forward_reports: configuration.forwardReports,
+    plugins: configuration.plugins?.map((plugin) => ({
+      name: plugin.name,
+      ...plugin.getConfigurationTelemetry?.(),
+    })),
+    ...baseSerializedInitConfiguration,
+  } satisfies RawTelemetryConfiguration
+}

package/src/domain/console/consoleCollection.ts

@@ -0,0 +1,58 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time'
+import { combine, ConsoleApiName } from '@kubesense/kubesense-js-core/util'
+import type { Context, Observable, BufferedData } from '@kubesense/kubesense-browser-core'
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
+import { BufferedDataType, ErrorSource } from '@kubesense/kubesense-browser-core'
+import type { LogsConfiguration } from '../configuration'
+import type { LifeCycle, RawLogsEventCollectedData } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import { StatusType } from '../logger/isAuthorized'
+import type { RawLogsEvent } from '../../rawLogsEvent.types'
+import { createErrorFieldFromRawError } from '../createErrorFieldFromRawError'
+
+export interface ProvidedError {
+  startClocks: ClocksState
+  error: unknown
+  context?: Context
+  handlingStack: string
+}
+
+export const LogStatusForApi = {
+  [ConsoleApiName.log]: StatusType.info,
+  [ConsoleApiName.debug]: StatusType.debug,
+  [ConsoleApiName.info]: StatusType.info,
+  [ConsoleApiName.warn]: StatusType.warn,
+  [ConsoleApiName.error]: StatusType.error,
+}
+
+export function startConsoleCollection(
+  configuration: LogsConfiguration,
+  lifeCycle: LifeCycle,
+  bufferedDataObservable: Observable<BufferedData>
+) {
+  const subscription = bufferedDataObservable.subscribe(({ data: log, type }) => {
+    if (type !== BufferedDataType.CONSOLE || !configuration.forwardConsoleLogs.includes(log.api)) {
+      return
+    }
+    const collectedData: RawLogsEventCollectedData<RawLogsEvent> = {
+      rawLogsEvent: combine(
+        {
+          date: timeStampNow(),
+          message: log.message,
+          origin: ErrorSource.CONSOLE,
+          error: log.error && createErrorFieldFromRawError(log.error),
+          _kubesense: log.error && { debug_ids: log.error.debugIds },
+          status: LogStatusForApi[log.api],
+        },
+        log.error?.context
+      ),
+      domainContext: {
+        handlingStack: log.handlingStack,
+      },
+    }
+
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, collectedData)
+  })
+
+  return { stop: () => subscription.unsubscribe() }
+}

package/src/domain/contexts/commonContext.ts

@@ -0,0 +1,15 @@
+import { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
+import type { CommonContext } from '../../rawLogsEvent.types'
+
+export function buildCommonContext(): CommonContext {
+  if (isWorkerEnvironment) {
+    return {}
+  }
+
+  return {
+    view: {
+      referrer: document.referrer,
+      url: window.location.href,
+    },
+  }
+}

package/src/domain/contexts/internalContext.ts

@@ -0,0 +1,19 @@
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time'
+import type { SessionManager } from '@kubesense/kubesense-browser-core'
+
+export interface InternalContext {
+  session_id: string | undefined
+}
+
+export function startInternalContext(sessionManager: SessionManager) {
+  return {
+    get: (startTime?: number): InternalContext | undefined => {
+      const trackedSession = sessionManager.findTrackedSession(startTime as RelativeTime)
+      if (trackedSession) {
+        return {
+          session_id: trackedSession.id,
+        }
+      }
+    },
+  }
+}

package/src/domain/contexts/rumInternalContext.ts

@@ -0,0 +1,60 @@
+import { globalObject } from '@kubesense/kubesense-js-core/util'
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time'
+import type { RumInternalContext } from '@kubesense/kubesense-browser-core'
+import { willSyntheticsInjectRum } from '@kubesense/kubesense-browser-core'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
+import type { Hooks } from '../hooks'
+
+interface Rum {
+  getInternalContext?: (startTime?: RelativeTime) => RumInternalContext | undefined
+}
+
+interface BrowserWindow {
+  KUBESENSE_SDK?: Rum
+  KUBESENSE_SDK_SYNTHETICS?: Rum
+}
+
+export function startRUMInternalContext(hooks: Hooks) {
+  const browserWindow = globalObject as BrowserWindow
+
+  hooks.assembleEventDefaults.register(({ startTime }) => {
+    const internalContext = getRUMInternalContext(startTime)
+    if (!internalContext) {
+      return SKIPPED
+    }
+
+    return internalContext
+  })
+
+  hooks.assembleTelemetry.register(({ startTime }) => {
+    const internalContext = getRUMInternalContext(startTime)
+
+    if (!internalContext) {
+      return SKIPPED
+    }
+
+    return {
+      application: { id: internalContext.application_id },
+      view: { id: internalContext.view?.id },
+      action: { id: internalContext.user_action?.id as string },
+    }
+  })
+
+  function getRUMInternalContext(startTime?: RelativeTime) {
+    const willSyntheticsInjectRumResult = willSyntheticsInjectRum()
+    const rumSource = willSyntheticsInjectRumResult
+      ? browserWindow.KUBESENSE_SDK_SYNTHETICS
+      : browserWindow.KUBESENSE_SDK
+    const rumContext = getInternalContextFromRumGlobal(startTime, rumSource)
+
+    if (rumContext) {
+      return rumContext
+    }
+  }
+
+  function getInternalContextFromRumGlobal(startTime?: RelativeTime, rumGlobal?: Rum): RumInternalContext | undefined {
+    if (rumGlobal?.getInternalContext) {
+      return rumGlobal.getInternalContext(startTime)
+    }
+  }
+}

package/src/domain/contexts/sessionContext.ts

@@ -0,0 +1,34 @@
+import type { SessionManager } from '@kubesense/kubesense-browser-core'
+import { DISCARDED } from '@kubesense/kubesense-js-core/assembly'
+import type { LogsConfiguration } from '../configuration'
+import type { AssembleHook } from '../hooks'
+
+export function startSessionContext(
+  hook: AssembleHook,
+  configuration: LogsConfiguration,
+  sessionManager: SessionManager
+) {
+  hook.register(({ startTime }) => {
+    // Used to attach a (fresh, safe-to-reference) session id: subject to the default
+    // TRACKED_SESSION_MAX_AGE, so it becomes undefined once the session is too old to reference.
+    const session = sessionManager.findTrackedSession(startTime)
+
+    // Used for the discard decision: unlike `session` above, this ignores session age (logs
+    // should keep being sent indefinitely, with or without a session, once a session was
+    // legitimately tracked here) but still respects sampling.
+    const isSessionTracked = sessionManager.findTrackedSession(startTime, {
+      returnInactive: true,
+      maxAge: Infinity,
+    })
+
+    if (!isSessionTracked) {
+      return DISCARDED
+    }
+
+    return {
+      service: configuration.service,
+      session_id: session ? session.id : undefined,
+      session: session ? { id: session.id } : undefined,
+    }
+  })
+}

package/src/domain/contexts/trackingConsentContext.ts

@@ -0,0 +1,18 @@
+import { DISCARDED, SKIPPED } from '@kubesense/kubesense-js-core/assembly'
+import type { TrackingConsentState } from '@kubesense/kubesense-browser-core'
+import type { Hooks } from '../hooks'
+
+export function startTrackingConsentContext(hooks: Hooks, trackingConsentState: TrackingConsentState) {
+  function isConsented() {
+    const wasConsented = trackingConsentState.isGranted()
+
+    if (!wasConsented) {
+      return DISCARDED
+    }
+
+    return SKIPPED
+  }
+
+  hooks.assembleEventDefaults.register(isConsented)
+  hooks.assembleTelemetry.register(isConsented)
+}

package/src/domain/createErrorFieldFromRawError.ts

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

package/src/domain/hooks.ts

@@ -0,0 +1,40 @@
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time'
+import type { TelemetryEvent } from '@kubesense/kubesense-browser-core'
+import { createHook } from '@kubesense/kubesense-js-core/assembly'
+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]>
+}
+
+// Use readonly and DeepReadonly to prevent assemble hook callbacks from mutating the inputs.
+// DeepReadonly is only applied to objects rather than the entire AssembleHookParams to avoid casts for primitives.
+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 function createHooks(): Hooks {
+  return {
+    assembleEventDefaults: createHook(),
+    assembleTelemetry: createHook(),
+    assembleEvent: createHook(),
+  }
+}

package/src/domain/lifeCycle.ts

@@ -0,0 +1,25 @@
+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 const enum LifeCycleEventType {
+  RAW_LOG_COLLECTED,
+  LOG_COLLECTED,
+}
+
+interface LifeCycleEventMap {
+  [LifeCycleEventType.RAW_LOG_COLLECTED]: RawLogsEventCollectedData
+  [LifeCycleEventType.LOG_COLLECTED]: LogsEvent & Context
+}
+
+export const LifeCycle = AbstractLifeCycle<LifeCycleEventMap>
+export type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>
+
+export interface RawLogsEventCollectedData<E extends RawLogsEvent = RawLogsEvent> {
+  rawLogsEvent: E
+  savedCommonContext?: CommonContext
+  domainContext?: LogsEventDomainContext<E['origin']>
+  ktags?: string[]
+}

package/src/domain/logger/isAuthorized.ts

@@ -0,0 +1,33 @@
+import type { Logger, HandlerType } from '../logger'
+
+export function isAuthorized(status: StatusType, handlerType: HandlerType, logger: Logger) {
+  const loggerHandler = logger.getHandler()
+  const sanitizedHandlerType = Array.isArray(loggerHandler) ? loggerHandler : [loggerHandler]
+  return STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && sanitizedHandlerType.includes(handlerType)
+}
+
+export const StatusType = {
+  ok: 'ok',
+  debug: 'debug',
+  info: 'info',
+  notice: 'notice',
+  warn: 'warn',
+  error: 'error',
+  critical: 'critical',
+  alert: 'alert',
+  emerg: 'emerg',
+} as const
+
+export const STATUS_PRIORITIES: { [key in StatusType]: number } = {
+  [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,
+}
+
+export type StatusType = (typeof StatusType)[keyof typeof StatusType]